31 using System.Runtime.InteropServices;
44 public static unsafe
class ImGui
54 int typeByteCount = 0;
57 typeByteCount = Encoding.UTF8.GetByteCount(type);
64 byte* nativeTypeStackBytes = stackalloc
byte[typeByteCount + 1];
65 nativeType = nativeTypeStackBytes;
68 int nativeTypeOffset =
Util.
GetUtf8(type, nativeType, typeByteCount);
69 nativeType[nativeTypeOffset] = 0;
95 int typeByteCount = 0;
98 typeByteCount = Encoding.UTF8.GetByteCount(type);
105 byte* nativeTypeStackBytes = stackalloc
byte[typeByteCount + 1];
106 nativeType = nativeTypeStackBytes;
109 int nativeTypeOffset =
Util.
GetUtf8(type, nativeType, typeByteCount);
110 nativeType[nativeTypeOffset] = 0;
143 int strIdByteCount = 0;
146 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
153 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
154 nativeStrId = nativeStrIdStackBytes;
157 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
158 nativeStrId[nativeStrIdOffset] = 0;
179 public static bool Begin(
string name)
182 int nameByteCount = 0;
185 nameByteCount = Encoding.UTF8.GetByteCount(name);
192 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
193 nativeName = nativeNameStackBytes;
196 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
197 nativeName[nativeNameOffset] = 0;
221 public static bool Begin(
string name, ref
bool pOpen)
224 int nameByteCount = 0;
227 nameByteCount = Encoding.UTF8.GetByteCount(name);
234 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
235 nativeName = nativeNameStackBytes;
238 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
239 nativeName[nativeNameOffset] = 0;
246 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
247 byte* nativePOpen = &nativePOpenVal;
255 pOpen = nativePOpenVal != 0;
269 int nameByteCount = 0;
272 nameByteCount = Encoding.UTF8.GetByteCount(name);
279 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
280 nativeName = nativeNameStackBytes;
283 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
284 nativeName[nativeNameOffset] = 0;
291 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
292 byte* nativePOpen = &nativePOpenVal;
299 pOpen = nativePOpenVal != 0;
311 int strIdByteCount = 0;
314 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
321 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
322 nativeStrId = nativeStrIdStackBytes;
325 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
326 nativeStrId[nativeStrIdOffset] = 0;
354 int strIdByteCount = 0;
357 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
364 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
365 nativeStrId = nativeStrIdStackBytes;
368 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
369 nativeStrId[nativeStrIdOffset] = 0;
397 int strIdByteCount = 0;
400 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
407 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
408 nativeStrId = nativeStrIdStackBytes;
411 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
412 nativeStrId[nativeStrIdOffset] = 0;
419 byte nativeBorder = border ? (byte) 1 : (
byte) 0;
441 int strIdByteCount = 0;
444 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
451 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
452 nativeStrId = nativeStrIdStackBytes;
455 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
456 nativeStrId[nativeStrIdOffset] = 0;
463 byte nativeBorder = border ? (byte) 1 : (
byte) 0;
510 byte nativeBorder = border ? (byte) 1 : (
byte) 0;
526 byte nativeBorder = border ? (byte) 1 : (
byte) 0;
563 public static bool BeginCombo(
string label,
string previewValue)
566 int labelByteCount = 0;
569 labelByteCount = Encoding.UTF8.GetByteCount(label);
576 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
577 nativeLabel = nativeLabelStackBytes;
580 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
581 nativeLabel[nativeLabelOffset] = 0;
588 byte* nativePreviewValue;
589 int previewValueByteCount = 0;
590 if (previewValue !=
null)
592 previewValueByteCount = Encoding.UTF8.GetByteCount(previewValue);
595 nativePreviewValue =
Util.
Allocate(previewValueByteCount + 1);
599 byte* nativePreviewValueStackBytes = stackalloc
byte[previewValueByteCount + 1];
600 nativePreviewValue = nativePreviewValueStackBytes;
603 int nativePreviewValueOffset =
Util.
GetUtf8(previewValue, nativePreviewValue, previewValueByteCount);
604 nativePreviewValue[nativePreviewValueOffset] = 0;
608 nativePreviewValue =
null;
636 int labelByteCount = 0;
639 labelByteCount = Encoding.UTF8.GetByteCount(label);
646 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
647 nativeLabel = nativeLabelStackBytes;
650 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
651 nativeLabel[nativeLabelOffset] = 0;
658 byte* nativePreviewValue;
659 int previewValueByteCount = 0;
660 if (previewValue !=
null)
662 previewValueByteCount = Encoding.UTF8.GetByteCount(previewValue);
665 nativePreviewValue =
Util.
Allocate(previewValueByteCount + 1);
669 byte* nativePreviewValueStackBytes = stackalloc
byte[previewValueByteCount + 1];
670 nativePreviewValue = nativePreviewValueStackBytes;
673 int nativePreviewValueOffset =
Util.
GetUtf8(previewValue, nativePreviewValue, previewValueByteCount);
674 nativePreviewValue[nativePreviewValueOffset] = 0;
678 nativePreviewValue =
null;
710 byte nativeDisabled = disabled ? (byte) 1 : (
byte) 0;
762 int labelByteCount = 0;
765 labelByteCount = Encoding.UTF8.GetByteCount(label);
772 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
773 nativeLabel = nativeLabelStackBytes;
776 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
777 nativeLabel[nativeLabelOffset] = 0;
803 int labelByteCount = 0;
806 labelByteCount = Encoding.UTF8.GetByteCount(label);
813 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
814 nativeLabel = nativeLabelStackBytes;
817 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
818 nativeLabel[nativeLabelOffset] = 0;
852 int labelByteCount = 0;
855 labelByteCount = Encoding.UTF8.GetByteCount(label);
862 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
863 nativeLabel = nativeLabelStackBytes;
866 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
867 nativeLabel[nativeLabelOffset] = 0;
890 public static bool BeginMenu(
string label,
bool enabled)
893 int labelByteCount = 0;
896 labelByteCount = Encoding.UTF8.GetByteCount(label);
903 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
904 nativeLabel = nativeLabelStackBytes;
907 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
908 nativeLabel[nativeLabelOffset] = 0;
915 byte nativeEnabled = enabled ? (byte) 1 : (
byte) 0;
943 int strIdByteCount = 0;
946 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
953 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
954 nativeStrId = nativeStrIdStackBytes;
957 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
958 nativeStrId[nativeStrIdOffset] = 0;
984 int strIdByteCount = 0;
987 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
994 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
995 nativeStrId = nativeStrIdStackBytes;
998 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
999 nativeStrId[nativeStrIdOffset] = 0;
1021 byte* nativeStrId =
null;
1035 int strIdByteCount = 0;
1038 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1045 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1046 nativeStrId = nativeStrIdStackBytes;
1049 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1050 nativeStrId[nativeStrIdOffset] = 0;
1076 int strIdByteCount = 0;
1079 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1086 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1087 nativeStrId = nativeStrIdStackBytes;
1090 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1091 nativeStrId[nativeStrIdOffset] = 0;
1113 byte* nativeStrId =
null;
1127 int strIdByteCount = 0;
1130 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1137 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1138 nativeStrId = nativeStrIdStackBytes;
1141 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1142 nativeStrId[nativeStrIdOffset] = 0;
1168 int strIdByteCount = 0;
1171 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1178 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1179 nativeStrId = nativeStrIdStackBytes;
1182 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1183 nativeStrId[nativeStrIdOffset] = 0;
1205 byte* nativeStrId =
null;
1219 int strIdByteCount = 0;
1222 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1229 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1230 nativeStrId = nativeStrIdStackBytes;
1233 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1234 nativeStrId[nativeStrIdOffset] = 0;
1260 int strIdByteCount = 0;
1263 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1270 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1271 nativeStrId = nativeStrIdStackBytes;
1274 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1275 nativeStrId[nativeStrIdOffset] = 0;
1299 int nameByteCount = 0;
1302 nameByteCount = Encoding.UTF8.GetByteCount(name);
1309 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
1310 nativeName = nativeNameStackBytes;
1313 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
1314 nativeName[nativeNameOffset] = 0;
1341 int nameByteCount = 0;
1344 nameByteCount = Encoding.UTF8.GetByteCount(name);
1351 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
1352 nativeName = nativeNameStackBytes;
1355 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
1356 nativeName[nativeNameOffset] = 0;
1363 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
1364 byte* nativePOpen = &nativePOpenVal;
1372 pOpen = nativePOpenVal != 0;
1386 int nameByteCount = 0;
1389 nameByteCount = Encoding.UTF8.GetByteCount(name);
1396 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
1397 nativeName = nativeNameStackBytes;
1400 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
1401 nativeName[nativeNameOffset] = 0;
1408 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
1409 byte* nativePOpen = &nativePOpenVal;
1416 pOpen = nativePOpenVal != 0;
1428 int strIdByteCount = 0;
1431 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1438 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1439 nativeStrId = nativeStrIdStackBytes;
1442 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1443 nativeStrId[nativeStrIdOffset] = 0;
1469 int strIdByteCount = 0;
1472 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1479 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1480 nativeStrId = nativeStrIdStackBytes;
1483 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1484 nativeStrId[nativeStrIdOffset] = 0;
1508 int labelByteCount = 0;
1511 labelByteCount = Encoding.UTF8.GetByteCount(label);
1518 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
1519 nativeLabel = nativeLabelStackBytes;
1522 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
1523 nativeLabel[nativeLabelOffset] = 0;
1550 int labelByteCount = 0;
1553 labelByteCount = Encoding.UTF8.GetByteCount(label);
1560 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
1561 nativeLabel = nativeLabelStackBytes;
1564 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
1565 nativeLabel[nativeLabelOffset] = 0;
1572 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
1573 byte* nativePOpen = &nativePOpenVal;
1581 pOpen = nativePOpenVal != 0;
1595 int labelByteCount = 0;
1598 labelByteCount = Encoding.UTF8.GetByteCount(label);
1605 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
1606 nativeLabel = nativeLabelStackBytes;
1609 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
1610 nativeLabel[nativeLabelOffset] = 0;
1617 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
1618 byte* nativePOpen = &nativePOpenVal;
1625 pOpen = nativePOpenVal != 0;
1638 int strIdByteCount = 0;
1641 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1648 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1649 nativeStrId = nativeStrIdStackBytes;
1652 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1653 nativeStrId[nativeStrIdOffset] = 0;
1662 float innerWidth = 0.0f;
1682 int strIdByteCount = 0;
1685 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1692 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1693 nativeStrId = nativeStrIdStackBytes;
1696 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1697 nativeStrId[nativeStrIdOffset] = 0;
1705 float innerWidth = 0.0f;
1726 int strIdByteCount = 0;
1729 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1736 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1737 nativeStrId = nativeStrIdStackBytes;
1740 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1741 nativeStrId[nativeStrIdOffset] = 0;
1748 float innerWidth = 0.0f;
1770 int strIdByteCount = 0;
1773 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1780 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
1781 nativeStrId = nativeStrIdStackBytes;
1784 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
1785 nativeStrId[nativeStrIdOffset] = 0;
1826 int fmtByteCount = 0;
1829 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
1836 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
1837 nativeFmt = nativeFmtStackBytes;
1840 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
1841 nativeFmt[nativeFmtOffset] = 0;
1863 int labelByteCount = 0;
1866 labelByteCount = Encoding.UTF8.GetByteCount(label);
1873 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
1874 nativeLabel = nativeLabelStackBytes;
1877 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
1878 nativeLabel[nativeLabelOffset] = 0;
1904 int labelByteCount = 0;
1907 labelByteCount = Encoding.UTF8.GetByteCount(label);
1914 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
1915 nativeLabel = nativeLabelStackBytes;
1918 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
1919 nativeLabel[nativeLabelOffset] = 0;
1954 int labelByteCount = 0;
1957 labelByteCount = Encoding.UTF8.GetByteCount(label);
1964 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
1965 nativeLabel = nativeLabelStackBytes;
1968 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
1969 nativeLabel[nativeLabelOffset] = 0;
1976 byte nativeVVal = v ? (byte) 1 : (
byte) 0;
1977 byte* nativeV = &nativeVVal;
1984 v = nativeVVal != 0;
1998 int labelByteCount = 0;
2001 labelByteCount = Encoding.UTF8.GetByteCount(label);
2008 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2009 nativeLabel = nativeLabelStackBytes;
2012 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2013 nativeLabel[nativeLabelOffset] = 0;
2020 fixed (
int* nativeFlags = &flags)
2042 int labelByteCount = 0;
2045 labelByteCount = Encoding.UTF8.GetByteCount(label);
2052 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2053 nativeLabel = nativeLabelStackBytes;
2056 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2057 nativeLabel[nativeLabelOffset] = 0;
2064 fixed (uint* nativeFlags = &flags)
2092 int labelByteCount = 0;
2095 labelByteCount = Encoding.UTF8.GetByteCount(label);
2102 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2103 nativeLabel = nativeLabelStackBytes;
2106 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2107 nativeLabel[nativeLabelOffset] = 0;
2133 int labelByteCount = 0;
2136 labelByteCount = Encoding.UTF8.GetByteCount(label);
2143 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2144 nativeLabel = nativeLabelStackBytes;
2147 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2148 nativeLabel[nativeLabelOffset] = 0;
2173 int labelByteCount = 0;
2176 labelByteCount = Encoding.UTF8.GetByteCount(label);
2183 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2184 nativeLabel = nativeLabelStackBytes;
2187 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2188 nativeLabel[nativeLabelOffset] = 0;
2195 byte nativePVisibleVal = pVisible ? (byte) 1 : (
byte) 0;
2196 byte* nativePVisible = &nativePVisibleVal;
2204 pVisible = nativePVisibleVal != 0;
2218 int labelByteCount = 0;
2221 labelByteCount = Encoding.UTF8.GetByteCount(label);
2228 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2229 nativeLabel = nativeLabelStackBytes;
2232 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2233 nativeLabel[nativeLabelOffset] = 0;
2240 byte nativePVisibleVal = pVisible ? (byte) 1 : (
byte) 0;
2241 byte* nativePVisible = &nativePVisibleVal;
2248 pVisible = nativePVisibleVal != 0;
2261 int descIdByteCount = 0;
2264 descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2271 byte* nativeDescIdStackBytes = stackalloc
byte[descIdByteCount + 1];
2272 nativeDescId = nativeDescIdStackBytes;
2275 int nativeDescIdOffset =
Util.
GetUtf8(descId, nativeDescId, descIdByteCount);
2276 nativeDescId[nativeDescIdOffset] = 0;
2280 nativeDescId =
null;
2304 int descIdByteCount = 0;
2307 descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2314 byte* nativeDescIdStackBytes = stackalloc
byte[descIdByteCount + 1];
2315 nativeDescId = nativeDescIdStackBytes;
2318 int nativeDescIdOffset =
Util.
GetUtf8(descId, nativeDescId, descIdByteCount);
2319 nativeDescId[nativeDescIdOffset] = 0;
2323 nativeDescId =
null;
2347 int descIdByteCount = 0;
2350 descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2357 byte* nativeDescIdStackBytes = stackalloc
byte[descIdByteCount + 1];
2358 nativeDescId = nativeDescIdStackBytes;
2361 int nativeDescIdOffset =
Util.
GetUtf8(descId, nativeDescId, descIdByteCount);
2362 nativeDescId[nativeDescIdOffset] = 0;
2366 nativeDescId =
null;
2399 fixed (
float* nativeOutR = &outR)
2401 fixed (
float* nativeOutG = &outG)
2403 fixed (
float* nativeOutB = &outB)
2422 fixed (
float* nativeOutH = &outH)
2424 fixed (
float* nativeOutS = &outS)
2426 fixed (
float* nativeOutV = &outV)
2455 int labelByteCount = 0;
2458 labelByteCount = Encoding.UTF8.GetByteCount(label);
2465 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2466 nativeLabel = nativeLabelStackBytes;
2469 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2470 nativeLabel[nativeLabelOffset] = 0;
2500 int labelByteCount = 0;
2503 labelByteCount = Encoding.UTF8.GetByteCount(label);
2510 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2511 nativeLabel = nativeLabelStackBytes;
2514 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2515 nativeLabel[nativeLabelOffset] = 0;
2543 int labelByteCount = 0;
2546 labelByteCount = Encoding.UTF8.GetByteCount(label);
2553 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2554 nativeLabel = nativeLabelStackBytes;
2557 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2558 nativeLabel[nativeLabelOffset] = 0;
2588 int labelByteCount = 0;
2591 labelByteCount = Encoding.UTF8.GetByteCount(label);
2598 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2599 nativeLabel = nativeLabelStackBytes;
2602 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2603 nativeLabel[nativeLabelOffset] = 0;
2631 int labelByteCount = 0;
2634 labelByteCount = Encoding.UTF8.GetByteCount(label);
2641 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2642 nativeLabel = nativeLabelStackBytes;
2645 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2646 nativeLabel[nativeLabelOffset] = 0;
2676 int labelByteCount = 0;
2679 labelByteCount = Encoding.UTF8.GetByteCount(label);
2686 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2687 nativeLabel = nativeLabelStackBytes;
2690 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2691 nativeLabel[nativeLabelOffset] = 0;
2719 int labelByteCount = 0;
2722 labelByteCount = Encoding.UTF8.GetByteCount(label);
2729 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2730 nativeLabel = nativeLabelStackBytes;
2733 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2734 nativeLabel[nativeLabelOffset] = 0;
2742 float* refCol =
null;
2765 int labelByteCount = 0;
2768 labelByteCount = Encoding.UTF8.GetByteCount(label);
2775 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2776 nativeLabel = nativeLabelStackBytes;
2779 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2780 nativeLabel[nativeLabelOffset] = 0;
2787 float* refCol =
null;
2811 int labelByteCount = 0;
2814 labelByteCount = Encoding.UTF8.GetByteCount(label);
2821 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2822 nativeLabel = nativeLabelStackBytes;
2825 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2826 nativeLabel[nativeLabelOffset] = 0;
2835 fixed (
float* nativeRefCol = &refCol)
2854 byte* nativeId =
null;
2865 byte* nativeId =
null;
2878 int idByteCount = 0;
2881 idByteCount = Encoding.UTF8.GetByteCount(
id);
2888 byte* nativeIdStackBytes = stackalloc
byte[idByteCount + 1];
2889 nativeId = nativeIdStackBytes;
2892 int nativeIdOffset =
Util.
GetUtf8(
id, nativeId, idByteCount);
2893 nativeId[nativeIdOffset] = 0;
2914 public static void Columns(
int count,
string id,
bool border)
2917 int idByteCount = 0;
2920 idByteCount = Encoding.UTF8.GetByteCount(
id);
2927 byte* nativeIdStackBytes = stackalloc
byte[idByteCount + 1];
2928 nativeId = nativeIdStackBytes;
2931 int nativeIdOffset =
Util.
GetUtf8(
id, nativeId, idByteCount);
2932 nativeId[nativeIdOffset] = 0;
2939 byte nativeBorder = border ? (byte) 1 : (
byte) 0;
2955 public static bool Combo(
string label, ref
int currentItem,
string[] items,
int itemsCount)
2958 int labelByteCount = 0;
2961 labelByteCount = Encoding.UTF8.GetByteCount(label);
2968 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
2969 nativeLabel = nativeLabelStackBytes;
2972 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
2973 nativeLabel[nativeLabelOffset] = 0;
2980 int* itemsByteCounts = stackalloc
int[items.Length];
2981 int itemsByteCount = 0;
2982 for (
int i = 0; i < items.Length; i++)
2984 string s = items[i];
2985 itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
2986 itemsByteCount += itemsByteCounts[i] + 1;
2989 byte* nativeItemsData = stackalloc
byte[itemsByteCount];
2991 for (
int i = 0; i < items.Length; i++)
2993 string s = items[i];
2994 fixed (
char* sPtr = s)
2996 offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
2997 nativeItemsData[offset] = 0;
3002 byte** nativeItems = stackalloc
byte*[items.Length];
3004 for (
int i = 0; i < items.Length; i++)
3006 nativeItems[i] = &nativeItemsData[offset];
3007 offset += itemsByteCounts[i] + 1;
3010 int popupMaxHeightInItems = -1;
3011 fixed (
int* nativeCurrentItem = ¤tItem)
3032 public static bool Combo(
string label, ref
int currentItem,
string[] items,
int itemsCount,
int popupMaxHeightInItems)
3035 int labelByteCount = 0;
3038 labelByteCount = Encoding.UTF8.GetByteCount(label);
3045 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3046 nativeLabel = nativeLabelStackBytes;
3049 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3050 nativeLabel[nativeLabelOffset] = 0;
3057 int* itemsByteCounts = stackalloc
int[items.Length];
3058 int itemsByteCount = 0;
3059 for (
int i = 0; i < items.Length; i++)
3061 string s = items[i];
3062 itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
3063 itemsByteCount += itemsByteCounts[i] + 1;
3066 byte* nativeItemsData = stackalloc
byte[itemsByteCount];
3068 for (
int i = 0; i < items.Length; i++)
3070 string s = items[i];
3071 fixed (
char* sPtr = s)
3073 offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
3074 nativeItemsData[offset] = 0;
3079 byte** nativeItems = stackalloc
byte*[items.Length];
3081 for (
int i = 0; i < items.Length; i++)
3083 nativeItems[i] = &nativeItemsData[offset];
3084 offset += itemsByteCounts[i] + 1;
3087 fixed (
int* nativeCurrentItem = ¤tItem)
3106 public static bool Combo(
string label, ref
int currentItem,
string itemsSeparatedByZeros)
3109 int labelByteCount = 0;
3112 labelByteCount = Encoding.UTF8.GetByteCount(label);
3119 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3120 nativeLabel = nativeLabelStackBytes;
3123 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3124 nativeLabel[nativeLabelOffset] = 0;
3131 byte* nativeItemsSeparatedByZeros;
3132 int itemsSeparatedByZerosByteCount = 0;
3133 if (itemsSeparatedByZeros !=
null)
3135 itemsSeparatedByZerosByteCount = Encoding.UTF8.GetByteCount(itemsSeparatedByZeros);
3138 nativeItemsSeparatedByZeros =
Util.
Allocate(itemsSeparatedByZerosByteCount + 1);
3142 byte* nativeItemsSeparatedByZerosStackBytes = stackalloc
byte[itemsSeparatedByZerosByteCount + 1];
3143 nativeItemsSeparatedByZeros = nativeItemsSeparatedByZerosStackBytes;
3146 int nativeItemsSeparatedByZerosOffset =
Util.
GetUtf8(itemsSeparatedByZeros, nativeItemsSeparatedByZeros, itemsSeparatedByZerosByteCount);
3147 nativeItemsSeparatedByZeros[nativeItemsSeparatedByZerosOffset] = 0;
3151 nativeItemsSeparatedByZeros =
null;
3154 int popupMaxHeightInItems = -1;
3155 fixed (
int* nativeCurrentItem = ¤tItem)
3157 byte ret =
ImGuiNative.
igCombo_Str(nativeLabel, nativeCurrentItem, nativeItemsSeparatedByZeros, popupMaxHeightInItems);
3165 Util.
Free(nativeItemsSeparatedByZeros);
3180 public static bool Combo(
string label, ref
int currentItem,
string itemsSeparatedByZeros,
int popupMaxHeightInItems)
3183 int labelByteCount = 0;
3186 labelByteCount = Encoding.UTF8.GetByteCount(label);
3193 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3194 nativeLabel = nativeLabelStackBytes;
3197 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3198 nativeLabel[nativeLabelOffset] = 0;
3205 byte* nativeItemsSeparatedByZeros;
3206 int itemsSeparatedByZerosByteCount = 0;
3207 if (itemsSeparatedByZeros !=
null)
3209 itemsSeparatedByZerosByteCount = Encoding.UTF8.GetByteCount(itemsSeparatedByZeros);
3212 nativeItemsSeparatedByZeros =
Util.
Allocate(itemsSeparatedByZerosByteCount + 1);
3216 byte* nativeItemsSeparatedByZerosStackBytes = stackalloc
byte[itemsSeparatedByZerosByteCount + 1];
3217 nativeItemsSeparatedByZeros = nativeItemsSeparatedByZerosStackBytes;
3220 int nativeItemsSeparatedByZerosOffset =
Util.
GetUtf8(itemsSeparatedByZeros, nativeItemsSeparatedByZeros, itemsSeparatedByZerosByteCount);
3221 nativeItemsSeparatedByZeros[nativeItemsSeparatedByZerosOffset] = 0;
3225 nativeItemsSeparatedByZeros =
null;
3228 fixed (
int* nativeCurrentItem = ¤tItem)
3230 byte ret =
ImGuiNative.
igCombo_Str(nativeLabel, nativeCurrentItem, nativeItemsSeparatedByZeros, popupMaxHeightInItems);
3238 Util.
Free(nativeItemsSeparatedByZeros);
3281 byte* nativeVersionStr;
3282 int versionStrByteCount = 0;
3283 if (versionStr !=
null)
3285 versionStrByteCount = Encoding.UTF8.GetByteCount(versionStr);
3288 nativeVersionStr =
Util.
Allocate(versionStrByteCount + 1);
3292 byte* nativeVersionStrStackBytes = stackalloc
byte[versionStrByteCount + 1];
3293 nativeVersionStr = nativeVersionStrStackBytes;
3296 int nativeVersionStrOffset =
Util.
GetUtf8(versionStr, nativeVersionStr, versionStrByteCount);
3297 nativeVersionStr[nativeVersionStrOffset] = 0;
3301 nativeVersionStr =
null;
3320 int textByteCount = 0;
3323 textByteCount = Encoding.UTF8.GetByteCount(text);
3330 byte* nativeTextStackBytes = stackalloc
byte[textByteCount + 1];
3331 nativeText = nativeTextStackBytes;
3334 int nativeTextOffset =
Util.
GetUtf8(text, nativeText, textByteCount);
3335 nativeText[nativeTextOffset] = 0;
3354 IntPtr ctx = IntPtr.Zero;
3497 int labelByteCount = 0;
3500 labelByteCount = Encoding.UTF8.GetByteCount(label);
3507 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3508 nativeLabel = nativeLabelStackBytes;
3511 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3512 nativeLabel[nativeLabelOffset] = 0;
3519 float vSpeed = 1.0f;
3523 int formatByteCount = 0;
3524 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
3531 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
3532 nativeFormat = nativeFormatStackBytes;
3535 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
3536 nativeFormat[nativeFormatOffset] = 0;
3538 fixed (
float* nativeV = &v)
3562 public static bool DragFloat(
string label, ref
float v,
float vSpeed)
3565 int labelByteCount = 0;
3568 labelByteCount = Encoding.UTF8.GetByteCount(label);
3575 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3576 nativeLabel = nativeLabelStackBytes;
3579 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3580 nativeLabel[nativeLabelOffset] = 0;
3590 int formatByteCount = 0;
3591 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
3598 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
3599 nativeFormat = nativeFormatStackBytes;
3602 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
3603 nativeFormat[nativeFormatOffset] = 0;
3605 fixed (
float* nativeV = &v)
3630 public static bool DragFloat(
string label, ref
float v,
float vSpeed,
float vMin)
3633 int labelByteCount = 0;
3636 labelByteCount = Encoding.UTF8.GetByteCount(label);
3643 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3644 nativeLabel = nativeLabelStackBytes;
3647 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3648 nativeLabel[nativeLabelOffset] = 0;
3657 int formatByteCount = 0;
3658 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
3665 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
3666 nativeFormat = nativeFormatStackBytes;
3669 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
3670 nativeFormat[nativeFormatOffset] = 0;
3672 fixed (
float* nativeV = &v)
3698 public static bool DragFloat(
string label, ref
float v,
float vSpeed,
float vMin,
float vMax)
3701 int labelByteCount = 0;
3704 labelByteCount = Encoding.UTF8.GetByteCount(label);
3711 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3712 nativeLabel = nativeLabelStackBytes;
3715 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3716 nativeLabel[nativeLabelOffset] = 0;
3724 int formatByteCount = 0;
3725 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
3732 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
3733 nativeFormat = nativeFormatStackBytes;
3736 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
3737 nativeFormat[nativeFormatOffset] = 0;
3739 fixed (
float* nativeV = &v)
3766 public static bool DragFloat(
string label, ref
float v,
float vSpeed,
float vMin,
float vMax,
string format)
3769 int labelByteCount = 0;
3772 labelByteCount = Encoding.UTF8.GetByteCount(label);
3779 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3780 nativeLabel = nativeLabelStackBytes;
3783 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3784 nativeLabel[nativeLabelOffset] = 0;
3792 int formatByteCount = 0;
3795 formatByteCount = Encoding.UTF8.GetByteCount(format);
3802 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
3803 nativeFormat = nativeFormatStackBytes;
3806 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
3807 nativeFormat[nativeFormatOffset] = 0;
3811 nativeFormat =
null;
3815 fixed (
float* nativeV = &v)
3846 int labelByteCount = 0;
3849 labelByteCount = Encoding.UTF8.GetByteCount(label);
3856 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3857 nativeLabel = nativeLabelStackBytes;
3860 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3861 nativeLabel[nativeLabelOffset] = 0;
3869 int formatByteCount = 0;
3872 formatByteCount = Encoding.UTF8.GetByteCount(format);
3879 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
3880 nativeFormat = nativeFormatStackBytes;
3883 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
3884 nativeFormat[nativeFormatOffset] = 0;
3888 nativeFormat =
null;
3891 fixed (
float* nativeV = &v)
3917 int labelByteCount = 0;
3920 labelByteCount = Encoding.UTF8.GetByteCount(label);
3927 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3928 nativeLabel = nativeLabelStackBytes;
3931 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
3932 nativeLabel[nativeLabelOffset] = 0;
3939 float vSpeed = 1.0f;
3943 int formatByteCount = 0;
3944 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
3951 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
3952 nativeFormat = nativeFormatStackBytes;
3955 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
3956 nativeFormat[nativeFormatOffset] = 0;
3985 int labelByteCount = 0;
3988 labelByteCount = Encoding.UTF8.GetByteCount(label);
3995 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
3996 nativeLabel = nativeLabelStackBytes;
3999 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4000 nativeLabel[nativeLabelOffset] = 0;
4010 int formatByteCount = 0;
4011 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4018 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4019 nativeFormat = nativeFormatStackBytes;
4022 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4023 nativeFormat[nativeFormatOffset] = 0;
4053 int labelByteCount = 0;
4056 labelByteCount = Encoding.UTF8.GetByteCount(label);
4063 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4064 nativeLabel = nativeLabelStackBytes;
4067 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4068 nativeLabel[nativeLabelOffset] = 0;
4077 int formatByteCount = 0;
4078 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4085 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4086 nativeFormat = nativeFormatStackBytes;
4089 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4090 nativeFormat[nativeFormatOffset] = 0;
4121 int labelByteCount = 0;
4124 labelByteCount = Encoding.UTF8.GetByteCount(label);
4131 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4132 nativeLabel = nativeLabelStackBytes;
4135 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4136 nativeLabel[nativeLabelOffset] = 0;
4144 int formatByteCount = 0;
4145 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4152 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4153 nativeFormat = nativeFormatStackBytes;
4156 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4157 nativeFormat[nativeFormatOffset] = 0;
4186 public static bool DragFloat2(
string label, ref
Vector2F v,
float vSpeed,
float vMin,
float vMax,
string format)
4189 int labelByteCount = 0;
4192 labelByteCount = Encoding.UTF8.GetByteCount(label);
4199 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4200 nativeLabel = nativeLabelStackBytes;
4203 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4204 nativeLabel[nativeLabelOffset] = 0;
4212 int formatByteCount = 0;
4215 formatByteCount = Encoding.UTF8.GetByteCount(format);
4222 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4223 nativeFormat = nativeFormatStackBytes;
4226 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
4227 nativeFormat[nativeFormatOffset] = 0;
4231 nativeFormat =
null;
4266 int labelByteCount = 0;
4269 labelByteCount = Encoding.UTF8.GetByteCount(label);
4276 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4277 nativeLabel = nativeLabelStackBytes;
4280 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4281 nativeLabel[nativeLabelOffset] = 0;
4289 int formatByteCount = 0;
4292 formatByteCount = Encoding.UTF8.GetByteCount(format);
4299 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4300 nativeFormat = nativeFormatStackBytes;
4303 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
4304 nativeFormat[nativeFormatOffset] = 0;
4308 nativeFormat =
null;
4337 int labelByteCount = 0;
4340 labelByteCount = Encoding.UTF8.GetByteCount(label);
4347 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4348 nativeLabel = nativeLabelStackBytes;
4351 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4352 nativeLabel[nativeLabelOffset] = 0;
4359 float vSpeed = 1.0f;
4363 int formatByteCount = 0;
4364 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4371 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4372 nativeFormat = nativeFormatStackBytes;
4375 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4376 nativeFormat[nativeFormatOffset] = 0;
4405 int labelByteCount = 0;
4408 labelByteCount = Encoding.UTF8.GetByteCount(label);
4415 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4416 nativeLabel = nativeLabelStackBytes;
4419 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4420 nativeLabel[nativeLabelOffset] = 0;
4430 int formatByteCount = 0;
4431 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4438 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4439 nativeFormat = nativeFormatStackBytes;
4442 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4443 nativeFormat[nativeFormatOffset] = 0;
4473 int labelByteCount = 0;
4476 labelByteCount = Encoding.UTF8.GetByteCount(label);
4483 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4484 nativeLabel = nativeLabelStackBytes;
4487 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4488 nativeLabel[nativeLabelOffset] = 0;
4497 int formatByteCount = 0;
4498 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4505 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4506 nativeFormat = nativeFormatStackBytes;
4509 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4510 nativeFormat[nativeFormatOffset] = 0;
4541 int labelByteCount = 0;
4544 labelByteCount = Encoding.UTF8.GetByteCount(label);
4551 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4552 nativeLabel = nativeLabelStackBytes;
4555 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4556 nativeLabel[nativeLabelOffset] = 0;
4564 int formatByteCount = 0;
4565 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4572 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4573 nativeFormat = nativeFormatStackBytes;
4576 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4577 nativeFormat[nativeFormatOffset] = 0;
4606 public static bool DragFloat3(
string label, ref
Vector3F v,
float vSpeed,
float vMin,
float vMax,
string format)
4609 int labelByteCount = 0;
4612 labelByteCount = Encoding.UTF8.GetByteCount(label);
4619 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4620 nativeLabel = nativeLabelStackBytes;
4623 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4624 nativeLabel[nativeLabelOffset] = 0;
4632 int formatByteCount = 0;
4635 formatByteCount = Encoding.UTF8.GetByteCount(format);
4642 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4643 nativeFormat = nativeFormatStackBytes;
4646 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
4647 nativeFormat[nativeFormatOffset] = 0;
4651 nativeFormat =
null;
4686 int labelByteCount = 0;
4689 labelByteCount = Encoding.UTF8.GetByteCount(label);
4696 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4697 nativeLabel = nativeLabelStackBytes;
4700 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4701 nativeLabel[nativeLabelOffset] = 0;
4709 int formatByteCount = 0;
4712 formatByteCount = Encoding.UTF8.GetByteCount(format);
4719 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4720 nativeFormat = nativeFormatStackBytes;
4723 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
4724 nativeFormat[nativeFormatOffset] = 0;
4728 nativeFormat =
null;
4757 int labelByteCount = 0;
4760 labelByteCount = Encoding.UTF8.GetByteCount(label);
4767 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4768 nativeLabel = nativeLabelStackBytes;
4771 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4772 nativeLabel[nativeLabelOffset] = 0;
4779 float vSpeed = 1.0f;
4783 int formatByteCount = 0;
4784 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4791 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4792 nativeFormat = nativeFormatStackBytes;
4795 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4796 nativeFormat[nativeFormatOffset] = 0;
4825 int labelByteCount = 0;
4828 labelByteCount = Encoding.UTF8.GetByteCount(label);
4835 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4836 nativeLabel = nativeLabelStackBytes;
4839 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4840 nativeLabel[nativeLabelOffset] = 0;
4850 int formatByteCount = 0;
4851 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4858 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4859 nativeFormat = nativeFormatStackBytes;
4862 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4863 nativeFormat[nativeFormatOffset] = 0;
4893 int labelByteCount = 0;
4896 labelByteCount = Encoding.UTF8.GetByteCount(label);
4903 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4904 nativeLabel = nativeLabelStackBytes;
4907 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4908 nativeLabel[nativeLabelOffset] = 0;
4917 int formatByteCount = 0;
4918 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4925 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4926 nativeFormat = nativeFormatStackBytes;
4929 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4930 nativeFormat[nativeFormatOffset] = 0;
4961 int labelByteCount = 0;
4964 labelByteCount = Encoding.UTF8.GetByteCount(label);
4971 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
4972 nativeLabel = nativeLabelStackBytes;
4975 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
4976 nativeLabel[nativeLabelOffset] = 0;
4984 int formatByteCount = 0;
4985 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
4992 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
4993 nativeFormat = nativeFormatStackBytes;
4996 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
4997 nativeFormat[nativeFormatOffset] = 0;
5026 public static bool DragFloat4(
string label, ref
Vector4F v,
float vSpeed,
float vMin,
float vMax,
string format)
5029 int labelByteCount = 0;
5032 labelByteCount = Encoding.UTF8.GetByteCount(label);
5039 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5040 nativeLabel = nativeLabelStackBytes;
5043 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5044 nativeLabel[nativeLabelOffset] = 0;
5052 int formatByteCount = 0;
5055 formatByteCount = Encoding.UTF8.GetByteCount(format);
5062 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5063 nativeFormat = nativeFormatStackBytes;
5066 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
5067 nativeFormat[nativeFormatOffset] = 0;
5071 nativeFormat =
null;
5106 int labelByteCount = 0;
5109 labelByteCount = Encoding.UTF8.GetByteCount(label);
5116 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5117 nativeLabel = nativeLabelStackBytes;
5120 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5121 nativeLabel[nativeLabelOffset] = 0;
5129 int formatByteCount = 0;
5132 formatByteCount = Encoding.UTF8.GetByteCount(format);
5139 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5140 nativeFormat = nativeFormatStackBytes;
5143 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
5144 nativeFormat[nativeFormatOffset] = 0;
5148 nativeFormat =
null;
5175 public static bool DragFloatRange2(
string label, ref
float vCurrentMin, ref
float vCurrentMax)
5178 int labelByteCount = 0;
5181 labelByteCount = Encoding.UTF8.GetByteCount(label);
5188 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5189 nativeLabel = nativeLabelStackBytes;
5192 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5193 nativeLabel[nativeLabelOffset] = 0;
5200 float vSpeed = 1.0f;
5204 int formatByteCount = 0;
5205 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
5212 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5213 nativeFormat = nativeFormatStackBytes;
5216 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
5217 nativeFormat[nativeFormatOffset] = 0;
5218 byte* nativeFormatMax =
null;
5220 fixed (
float* nativeVCurrentMin = &vCurrentMin)
5222 fixed (
float* nativeVCurrentMax = &vCurrentMax)
5224 byte ret =
ImGuiNative.
igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5248 public static bool DragFloatRange2(
string label, ref
float vCurrentMin, ref
float vCurrentMax,
float vSpeed)
5251 int labelByteCount = 0;
5254 labelByteCount = Encoding.UTF8.GetByteCount(label);
5261 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5262 nativeLabel = nativeLabelStackBytes;
5265 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5266 nativeLabel[nativeLabelOffset] = 0;
5276 int formatByteCount = 0;
5277 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
5284 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5285 nativeFormat = nativeFormatStackBytes;
5288 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
5289 nativeFormat[nativeFormatOffset] = 0;
5290 byte* nativeFormatMax =
null;
5292 fixed (
float* nativeVCurrentMin = &vCurrentMin)
5294 fixed (
float* nativeVCurrentMax = &vCurrentMax)
5296 byte ret =
ImGuiNative.
igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5321 public static bool DragFloatRange2(
string label, ref
float vCurrentMin, ref
float vCurrentMax,
float vSpeed,
float vMin)
5324 int labelByteCount = 0;
5327 labelByteCount = Encoding.UTF8.GetByteCount(label);
5334 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5335 nativeLabel = nativeLabelStackBytes;
5338 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5339 nativeLabel[nativeLabelOffset] = 0;
5348 int formatByteCount = 0;
5349 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
5356 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5357 nativeFormat = nativeFormatStackBytes;
5360 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
5361 nativeFormat[nativeFormatOffset] = 0;
5362 byte* nativeFormatMax =
null;
5364 fixed (
float* nativeVCurrentMin = &vCurrentMin)
5366 fixed (
float* nativeVCurrentMax = &vCurrentMax)
5368 byte ret =
ImGuiNative.
igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5394 public static bool DragFloatRange2(
string label, ref
float vCurrentMin, ref
float vCurrentMax,
float vSpeed,
float vMin,
float vMax)
5397 int labelByteCount = 0;
5400 labelByteCount = Encoding.UTF8.GetByteCount(label);
5407 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5408 nativeLabel = nativeLabelStackBytes;
5411 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5412 nativeLabel[nativeLabelOffset] = 0;
5420 int formatByteCount = 0;
5421 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
5428 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5429 nativeFormat = nativeFormatStackBytes;
5432 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
5433 nativeFormat[nativeFormatOffset] = 0;
5434 byte* nativeFormatMax =
null;
5436 fixed (
float* nativeVCurrentMin = &vCurrentMin)
5438 fixed (
float* nativeVCurrentMax = &vCurrentMax)
5440 byte ret =
ImGuiNative.
igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5467 public static bool DragFloatRange2(
string label, ref
float vCurrentMin, ref
float vCurrentMax,
float vSpeed,
float vMin,
float vMax,
string format)
5470 int labelByteCount = 0;
5473 labelByteCount = Encoding.UTF8.GetByteCount(label);
5480 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5481 nativeLabel = nativeLabelStackBytes;
5484 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5485 nativeLabel[nativeLabelOffset] = 0;
5493 int formatByteCount = 0;
5496 formatByteCount = Encoding.UTF8.GetByteCount(format);
5503 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5504 nativeFormat = nativeFormatStackBytes;
5507 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
5508 nativeFormat[nativeFormatOffset] = 0;
5512 nativeFormat =
null;
5515 byte* nativeFormatMax =
null;
5517 fixed (
float* nativeVCurrentMin = &vCurrentMin)
5519 fixed (
float* nativeVCurrentMax = &vCurrentMax)
5521 byte ret =
ImGuiNative.
igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5549 public static bool DragFloatRange2(
string label, ref
float vCurrentMin, ref
float vCurrentMax,
float vSpeed,
float vMin,
float vMax,
string format,
string formatMax)
5552 int labelByteCount = 0;
5555 labelByteCount = Encoding.UTF8.GetByteCount(label);
5562 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5563 nativeLabel = nativeLabelStackBytes;
5566 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5567 nativeLabel[nativeLabelOffset] = 0;
5575 int formatByteCount = 0;
5578 formatByteCount = Encoding.UTF8.GetByteCount(format);
5585 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5586 nativeFormat = nativeFormatStackBytes;
5589 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
5590 nativeFormat[nativeFormatOffset] = 0;
5594 nativeFormat =
null;
5597 byte* nativeFormatMax;
5598 int formatMaxByteCount = 0;
5599 if (formatMax !=
null)
5601 formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
5604 nativeFormatMax =
Util.
Allocate(formatMaxByteCount + 1);
5608 byte* nativeFormatMaxStackBytes = stackalloc
byte[formatMaxByteCount + 1];
5609 nativeFormatMax = nativeFormatMaxStackBytes;
5612 int nativeFormatMaxOffset =
Util.
GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
5613 nativeFormatMax[nativeFormatMaxOffset] = 0;
5617 nativeFormatMax =
null;
5621 fixed (
float* nativeVCurrentMin = &vCurrentMin)
5623 fixed (
float* nativeVCurrentMax = &vCurrentMax)
5625 byte ret =
ImGuiNative.
igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5659 public static bool DragFloatRange2(
string label, ref
float vCurrentMin, ref
float vCurrentMax,
float vSpeed,
float vMin,
float vMax,
string format,
string formatMax,
ImGuiSliderFlags flags)
5662 int labelByteCount = 0;
5665 labelByteCount = Encoding.UTF8.GetByteCount(label);
5672 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5673 nativeLabel = nativeLabelStackBytes;
5676 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5677 nativeLabel[nativeLabelOffset] = 0;
5685 int formatByteCount = 0;
5688 formatByteCount = Encoding.UTF8.GetByteCount(format);
5695 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5696 nativeFormat = nativeFormatStackBytes;
5699 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
5700 nativeFormat[nativeFormatOffset] = 0;
5704 nativeFormat =
null;
5707 byte* nativeFormatMax;
5708 int formatMaxByteCount = 0;
5709 if (formatMax !=
null)
5711 formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
5714 nativeFormatMax =
Util.
Allocate(formatMaxByteCount + 1);
5718 byte* nativeFormatMaxStackBytes = stackalloc
byte[formatMaxByteCount + 1];
5719 nativeFormatMax = nativeFormatMaxStackBytes;
5722 int nativeFormatMaxOffset =
Util.
GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
5723 nativeFormatMax[nativeFormatMaxOffset] = 0;
5727 nativeFormatMax =
null;
5730 fixed (
float* nativeVCurrentMin = &vCurrentMin)
5732 fixed (
float* nativeVCurrentMax = &vCurrentMax)
5734 byte ret =
ImGuiNative.
igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5761 public static bool DragInt(
string label, ref
int v)
5764 int labelByteCount = 0;
5767 labelByteCount = Encoding.UTF8.GetByteCount(label);
5774 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5775 nativeLabel = nativeLabelStackBytes;
5778 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5779 nativeLabel[nativeLabelOffset] = 0;
5786 float vSpeed = 1.0f;
5790 int formatByteCount = 0;
5791 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
5798 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5799 nativeFormat = nativeFormatStackBytes;
5802 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
5803 nativeFormat[nativeFormatOffset] = 0;
5805 fixed (
int* nativeV = &v)
5807 byte ret =
ImGuiNative.
igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5829 public static bool DragInt(
string label, ref
int v,
float vSpeed)
5832 int labelByteCount = 0;
5835 labelByteCount = Encoding.UTF8.GetByteCount(label);
5842 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5843 nativeLabel = nativeLabelStackBytes;
5846 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5847 nativeLabel[nativeLabelOffset] = 0;
5857 int formatByteCount = 0;
5858 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
5865 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5866 nativeFormat = nativeFormatStackBytes;
5869 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
5870 nativeFormat[nativeFormatOffset] = 0;
5872 fixed (
int* nativeV = &v)
5874 byte ret =
ImGuiNative.
igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5897 public static bool DragInt(
string label, ref
int v,
float vSpeed,
int vMin)
5900 int labelByteCount = 0;
5903 labelByteCount = Encoding.UTF8.GetByteCount(label);
5910 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5911 nativeLabel = nativeLabelStackBytes;
5914 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5915 nativeLabel[nativeLabelOffset] = 0;
5924 int formatByteCount = 0;
5925 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
5932 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
5933 nativeFormat = nativeFormatStackBytes;
5936 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
5937 nativeFormat[nativeFormatOffset] = 0;
5939 fixed (
int* nativeV = &v)
5941 byte ret =
ImGuiNative.
igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5965 public static bool DragInt(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax)
5968 int labelByteCount = 0;
5971 labelByteCount = Encoding.UTF8.GetByteCount(label);
5978 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
5979 nativeLabel = nativeLabelStackBytes;
5982 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
5983 nativeLabel[nativeLabelOffset] = 0;
5991 int formatByteCount = 0;
5992 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
5999 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6000 nativeFormat = nativeFormatStackBytes;
6003 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6004 nativeFormat[nativeFormatOffset] = 0;
6006 fixed (
int* nativeV = &v)
6008 byte ret =
ImGuiNative.
igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6033 public static bool DragInt(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax,
string format)
6036 int labelByteCount = 0;
6039 labelByteCount = Encoding.UTF8.GetByteCount(label);
6046 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6047 nativeLabel = nativeLabelStackBytes;
6050 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6051 nativeLabel[nativeLabelOffset] = 0;
6059 int formatByteCount = 0;
6062 formatByteCount = Encoding.UTF8.GetByteCount(format);
6069 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6070 nativeFormat = nativeFormatStackBytes;
6073 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
6074 nativeFormat[nativeFormatOffset] = 0;
6078 nativeFormat =
null;
6082 fixed (
int* nativeV = &v)
6084 byte ret =
ImGuiNative.
igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6113 int labelByteCount = 0;
6116 labelByteCount = Encoding.UTF8.GetByteCount(label);
6123 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6124 nativeLabel = nativeLabelStackBytes;
6127 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6128 nativeLabel[nativeLabelOffset] = 0;
6136 int formatByteCount = 0;
6139 formatByteCount = Encoding.UTF8.GetByteCount(format);
6146 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6147 nativeFormat = nativeFormatStackBytes;
6150 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
6151 nativeFormat[nativeFormatOffset] = 0;
6155 nativeFormat =
null;
6158 fixed (
int* nativeV = &v)
6160 byte ret =
ImGuiNative.
igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6184 int labelByteCount = 0;
6187 labelByteCount = Encoding.UTF8.GetByteCount(label);
6194 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6195 nativeLabel = nativeLabelStackBytes;
6198 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6199 nativeLabel[nativeLabelOffset] = 0;
6206 float vSpeed = 1.0f;
6210 int formatByteCount = 0;
6211 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6218 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6219 nativeFormat = nativeFormatStackBytes;
6222 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6223 nativeFormat[nativeFormatOffset] = 0;
6225 fixed (
int* nativeV = &v)
6249 public static bool DragInt2(
string label, ref
int v,
float vSpeed)
6252 int labelByteCount = 0;
6255 labelByteCount = Encoding.UTF8.GetByteCount(label);
6262 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6263 nativeLabel = nativeLabelStackBytes;
6266 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6267 nativeLabel[nativeLabelOffset] = 0;
6277 int formatByteCount = 0;
6278 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6285 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6286 nativeFormat = nativeFormatStackBytes;
6289 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6290 nativeFormat[nativeFormatOffset] = 0;
6292 fixed (
int* nativeV = &v)
6317 public static bool DragInt2(
string label, ref
int v,
float vSpeed,
int vMin)
6320 int labelByteCount = 0;
6323 labelByteCount = Encoding.UTF8.GetByteCount(label);
6330 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6331 nativeLabel = nativeLabelStackBytes;
6334 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6335 nativeLabel[nativeLabelOffset] = 0;
6344 int formatByteCount = 0;
6345 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6352 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6353 nativeFormat = nativeFormatStackBytes;
6356 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6357 nativeFormat[nativeFormatOffset] = 0;
6359 fixed (
int* nativeV = &v)
6385 public static bool DragInt2(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax)
6388 int labelByteCount = 0;
6391 labelByteCount = Encoding.UTF8.GetByteCount(label);
6398 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6399 nativeLabel = nativeLabelStackBytes;
6402 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6403 nativeLabel[nativeLabelOffset] = 0;
6411 int formatByteCount = 0;
6412 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6419 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6420 nativeFormat = nativeFormatStackBytes;
6423 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6424 nativeFormat[nativeFormatOffset] = 0;
6426 fixed (
int* nativeV = &v)
6453 public static bool DragInt2(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax,
string format)
6456 int labelByteCount = 0;
6459 labelByteCount = Encoding.UTF8.GetByteCount(label);
6466 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6467 nativeLabel = nativeLabelStackBytes;
6470 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6471 nativeLabel[nativeLabelOffset] = 0;
6479 int formatByteCount = 0;
6482 formatByteCount = Encoding.UTF8.GetByteCount(format);
6489 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6490 nativeFormat = nativeFormatStackBytes;
6493 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
6494 nativeFormat[nativeFormatOffset] = 0;
6498 nativeFormat =
null;
6502 fixed (
int* nativeV = &v)
6533 int labelByteCount = 0;
6536 labelByteCount = Encoding.UTF8.GetByteCount(label);
6543 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6544 nativeLabel = nativeLabelStackBytes;
6547 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6548 nativeLabel[nativeLabelOffset] = 0;
6556 int formatByteCount = 0;
6559 formatByteCount = Encoding.UTF8.GetByteCount(format);
6566 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6567 nativeFormat = nativeFormatStackBytes;
6570 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
6571 nativeFormat[nativeFormatOffset] = 0;
6575 nativeFormat =
null;
6578 fixed (
int* nativeV = &v)
6604 int labelByteCount = 0;
6607 labelByteCount = Encoding.UTF8.GetByteCount(label);
6614 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6615 nativeLabel = nativeLabelStackBytes;
6618 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6619 nativeLabel[nativeLabelOffset] = 0;
6626 float vSpeed = 1.0f;
6630 int formatByteCount = 0;
6631 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6638 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6639 nativeFormat = nativeFormatStackBytes;
6642 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6643 nativeFormat[nativeFormatOffset] = 0;
6645 fixed (
int* nativeV = &v)
6669 public static bool DragInt3(
string label, ref
int v,
float vSpeed)
6672 int labelByteCount = 0;
6675 labelByteCount = Encoding.UTF8.GetByteCount(label);
6682 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6683 nativeLabel = nativeLabelStackBytes;
6686 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6687 nativeLabel[nativeLabelOffset] = 0;
6697 int formatByteCount = 0;
6698 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6705 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6706 nativeFormat = nativeFormatStackBytes;
6709 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6710 nativeFormat[nativeFormatOffset] = 0;
6712 fixed (
int* nativeV = &v)
6737 public static bool DragInt3(
string label, ref
int v,
float vSpeed,
int vMin)
6740 int labelByteCount = 0;
6743 labelByteCount = Encoding.UTF8.GetByteCount(label);
6750 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6751 nativeLabel = nativeLabelStackBytes;
6754 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6755 nativeLabel[nativeLabelOffset] = 0;
6764 int formatByteCount = 0;
6765 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6772 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6773 nativeFormat = nativeFormatStackBytes;
6776 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6777 nativeFormat[nativeFormatOffset] = 0;
6779 fixed (
int* nativeV = &v)
6805 public static bool DragInt3(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax)
6808 int labelByteCount = 0;
6811 labelByteCount = Encoding.UTF8.GetByteCount(label);
6818 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6819 nativeLabel = nativeLabelStackBytes;
6822 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6823 nativeLabel[nativeLabelOffset] = 0;
6831 int formatByteCount = 0;
6832 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
6839 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6840 nativeFormat = nativeFormatStackBytes;
6843 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
6844 nativeFormat[nativeFormatOffset] = 0;
6846 fixed (
int* nativeV = &v)
6873 public static bool DragInt3(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax,
string format)
6876 int labelByteCount = 0;
6879 labelByteCount = Encoding.UTF8.GetByteCount(label);
6886 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6887 nativeLabel = nativeLabelStackBytes;
6890 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6891 nativeLabel[nativeLabelOffset] = 0;
6899 int formatByteCount = 0;
6902 formatByteCount = Encoding.UTF8.GetByteCount(format);
6909 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6910 nativeFormat = nativeFormatStackBytes;
6913 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
6914 nativeFormat[nativeFormatOffset] = 0;
6918 nativeFormat =
null;
6922 fixed (
int* nativeV = &v)
6953 int labelByteCount = 0;
6956 labelByteCount = Encoding.UTF8.GetByteCount(label);
6963 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
6964 nativeLabel = nativeLabelStackBytes;
6967 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
6968 nativeLabel[nativeLabelOffset] = 0;
6976 int formatByteCount = 0;
6979 formatByteCount = Encoding.UTF8.GetByteCount(format);
6986 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
6987 nativeFormat = nativeFormatStackBytes;
6990 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
6991 nativeFormat[nativeFormatOffset] = 0;
6995 nativeFormat =
null;
6998 fixed (
int* nativeV = &v)
7024 int labelByteCount = 0;
7027 labelByteCount = Encoding.UTF8.GetByteCount(label);
7034 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7035 nativeLabel = nativeLabelStackBytes;
7038 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7039 nativeLabel[nativeLabelOffset] = 0;
7046 float vSpeed = 1.0f;
7050 int formatByteCount = 0;
7051 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7058 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7059 nativeFormat = nativeFormatStackBytes;
7062 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7063 nativeFormat[nativeFormatOffset] = 0;
7065 fixed (
int* nativeV = &v)
7089 public static bool DragInt4(
string label, ref
int v,
float vSpeed)
7092 int labelByteCount = 0;
7095 labelByteCount = Encoding.UTF8.GetByteCount(label);
7102 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7103 nativeLabel = nativeLabelStackBytes;
7106 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7107 nativeLabel[nativeLabelOffset] = 0;
7117 int formatByteCount = 0;
7118 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7125 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7126 nativeFormat = nativeFormatStackBytes;
7129 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7130 nativeFormat[nativeFormatOffset] = 0;
7132 fixed (
int* nativeV = &v)
7157 public static bool DragInt4(
string label, ref
int v,
float vSpeed,
int vMin)
7160 int labelByteCount = 0;
7163 labelByteCount = Encoding.UTF8.GetByteCount(label);
7170 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7171 nativeLabel = nativeLabelStackBytes;
7174 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7175 nativeLabel[nativeLabelOffset] = 0;
7184 int formatByteCount = 0;
7185 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7192 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7193 nativeFormat = nativeFormatStackBytes;
7196 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7197 nativeFormat[nativeFormatOffset] = 0;
7199 fixed (
int* nativeV = &v)
7225 public static bool DragInt4(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax)
7228 int labelByteCount = 0;
7231 labelByteCount = Encoding.UTF8.GetByteCount(label);
7238 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7239 nativeLabel = nativeLabelStackBytes;
7242 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7243 nativeLabel[nativeLabelOffset] = 0;
7251 int formatByteCount = 0;
7252 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7259 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7260 nativeFormat = nativeFormatStackBytes;
7263 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7264 nativeFormat[nativeFormatOffset] = 0;
7266 fixed (
int* nativeV = &v)
7293 public static bool DragInt4(
string label, ref
int v,
float vSpeed,
int vMin,
int vMax,
string format)
7296 int labelByteCount = 0;
7299 labelByteCount = Encoding.UTF8.GetByteCount(label);
7306 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7307 nativeLabel = nativeLabelStackBytes;
7310 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7311 nativeLabel[nativeLabelOffset] = 0;
7319 int formatByteCount = 0;
7322 formatByteCount = Encoding.UTF8.GetByteCount(format);
7329 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7330 nativeFormat = nativeFormatStackBytes;
7333 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
7334 nativeFormat[nativeFormatOffset] = 0;
7338 nativeFormat =
null;
7342 fixed (
int* nativeV = &v)
7373 int labelByteCount = 0;
7376 labelByteCount = Encoding.UTF8.GetByteCount(label);
7383 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7384 nativeLabel = nativeLabelStackBytes;
7387 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7388 nativeLabel[nativeLabelOffset] = 0;
7396 int formatByteCount = 0;
7399 formatByteCount = Encoding.UTF8.GetByteCount(format);
7406 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7407 nativeFormat = nativeFormatStackBytes;
7410 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
7411 nativeFormat[nativeFormatOffset] = 0;
7415 nativeFormat =
null;
7418 fixed (
int* nativeV = &v)
7442 public static bool DragIntRange2(
string label, ref
int vCurrentMin, ref
int vCurrentMax)
7445 int labelByteCount = 0;
7448 labelByteCount = Encoding.UTF8.GetByteCount(label);
7455 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7456 nativeLabel = nativeLabelStackBytes;
7459 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7460 nativeLabel[nativeLabelOffset] = 0;
7467 float vSpeed = 1.0f;
7471 int formatByteCount = 0;
7472 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7479 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7480 nativeFormat = nativeFormatStackBytes;
7483 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7484 nativeFormat[nativeFormatOffset] = 0;
7485 byte* nativeFormatMax =
null;
7487 fixed (
int* nativeVCurrentMin = &vCurrentMin)
7489 fixed (
int* nativeVCurrentMax = &vCurrentMax)
7491 byte ret =
ImGuiNative.
igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7515 public static bool DragIntRange2(
string label, ref
int vCurrentMin, ref
int vCurrentMax,
float vSpeed)
7518 int labelByteCount = 0;
7521 labelByteCount = Encoding.UTF8.GetByteCount(label);
7528 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7529 nativeLabel = nativeLabelStackBytes;
7532 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7533 nativeLabel[nativeLabelOffset] = 0;
7543 int formatByteCount = 0;
7544 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7551 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7552 nativeFormat = nativeFormatStackBytes;
7555 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7556 nativeFormat[nativeFormatOffset] = 0;
7557 byte* nativeFormatMax =
null;
7559 fixed (
int* nativeVCurrentMin = &vCurrentMin)
7561 fixed (
int* nativeVCurrentMax = &vCurrentMax)
7563 byte ret =
ImGuiNative.
igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7588 public static bool DragIntRange2(
string label, ref
int vCurrentMin, ref
int vCurrentMax,
float vSpeed,
int vMin)
7591 int labelByteCount = 0;
7594 labelByteCount = Encoding.UTF8.GetByteCount(label);
7601 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7602 nativeLabel = nativeLabelStackBytes;
7605 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7606 nativeLabel[nativeLabelOffset] = 0;
7615 int formatByteCount = 0;
7616 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7623 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7624 nativeFormat = nativeFormatStackBytes;
7627 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7628 nativeFormat[nativeFormatOffset] = 0;
7629 byte* nativeFormatMax =
null;
7631 fixed (
int* nativeVCurrentMin = &vCurrentMin)
7633 fixed (
int* nativeVCurrentMax = &vCurrentMax)
7635 byte ret =
ImGuiNative.
igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7661 public static bool DragIntRange2(
string label, ref
int vCurrentMin, ref
int vCurrentMax,
float vSpeed,
int vMin,
int vMax)
7664 int labelByteCount = 0;
7667 labelByteCount = Encoding.UTF8.GetByteCount(label);
7674 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7675 nativeLabel = nativeLabelStackBytes;
7678 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7679 nativeLabel[nativeLabelOffset] = 0;
7687 int formatByteCount = 0;
7688 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
7695 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7696 nativeFormat = nativeFormatStackBytes;
7699 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
7700 nativeFormat[nativeFormatOffset] = 0;
7701 byte* nativeFormatMax =
null;
7703 fixed (
int* nativeVCurrentMin = &vCurrentMin)
7705 fixed (
int* nativeVCurrentMax = &vCurrentMax)
7707 byte ret =
ImGuiNative.
igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7734 public static bool DragIntRange2(
string label, ref
int vCurrentMin, ref
int vCurrentMax,
float vSpeed,
int vMin,
int vMax,
string format)
7737 int labelByteCount = 0;
7740 labelByteCount = Encoding.UTF8.GetByteCount(label);
7747 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7748 nativeLabel = nativeLabelStackBytes;
7751 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7752 nativeLabel[nativeLabelOffset] = 0;
7760 int formatByteCount = 0;
7763 formatByteCount = Encoding.UTF8.GetByteCount(format);
7770 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7771 nativeFormat = nativeFormatStackBytes;
7774 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
7775 nativeFormat[nativeFormatOffset] = 0;
7779 nativeFormat =
null;
7782 byte* nativeFormatMax =
null;
7784 fixed (
int* nativeVCurrentMin = &vCurrentMin)
7786 fixed (
int* nativeVCurrentMax = &vCurrentMax)
7788 byte ret =
ImGuiNative.
igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7816 public static bool DragIntRange2(
string label, ref
int vCurrentMin, ref
int vCurrentMax,
float vSpeed,
int vMin,
int vMax,
string format,
string formatMax)
7819 int labelByteCount = 0;
7822 labelByteCount = Encoding.UTF8.GetByteCount(label);
7829 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7830 nativeLabel = nativeLabelStackBytes;
7833 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7834 nativeLabel[nativeLabelOffset] = 0;
7842 int formatByteCount = 0;
7845 formatByteCount = Encoding.UTF8.GetByteCount(format);
7852 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7853 nativeFormat = nativeFormatStackBytes;
7856 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
7857 nativeFormat[nativeFormatOffset] = 0;
7861 nativeFormat =
null;
7864 byte* nativeFormatMax;
7865 int formatMaxByteCount = 0;
7866 if (formatMax !=
null)
7868 formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
7871 nativeFormatMax =
Util.
Allocate(formatMaxByteCount + 1);
7875 byte* nativeFormatMaxStackBytes = stackalloc
byte[formatMaxByteCount + 1];
7876 nativeFormatMax = nativeFormatMaxStackBytes;
7879 int nativeFormatMaxOffset =
Util.
GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
7880 nativeFormatMax[nativeFormatMaxOffset] = 0;
7884 nativeFormatMax =
null;
7888 fixed (
int* nativeVCurrentMin = &vCurrentMin)
7890 fixed (
int* nativeVCurrentMax = &vCurrentMax)
7892 byte ret =
ImGuiNative.
igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7926 public static bool DragIntRange2(
string label, ref
int vCurrentMin, ref
int vCurrentMax,
float vSpeed,
int vMin,
int vMax,
string format,
string formatMax,
ImGuiSliderFlags flags)
7929 int labelByteCount = 0;
7932 labelByteCount = Encoding.UTF8.GetByteCount(label);
7939 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
7940 nativeLabel = nativeLabelStackBytes;
7943 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
7944 nativeLabel[nativeLabelOffset] = 0;
7952 int formatByteCount = 0;
7955 formatByteCount = Encoding.UTF8.GetByteCount(format);
7962 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
7963 nativeFormat = nativeFormatStackBytes;
7966 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
7967 nativeFormat[nativeFormatOffset] = 0;
7971 nativeFormat =
null;
7974 byte* nativeFormatMax;
7975 int formatMaxByteCount = 0;
7976 if (formatMax !=
null)
7978 formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
7981 nativeFormatMax =
Util.
Allocate(formatMaxByteCount + 1);
7985 byte* nativeFormatMaxStackBytes = stackalloc
byte[formatMaxByteCount + 1];
7986 nativeFormatMax = nativeFormatMaxStackBytes;
7989 int nativeFormatMaxOffset =
Util.
GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
7990 nativeFormatMax[nativeFormatMaxOffset] = 0;
7994 nativeFormatMax =
null;
7997 fixed (
int* nativeVCurrentMin = &vCurrentMin)
7999 fixed (
int* nativeVCurrentMax = &vCurrentMax)
8001 byte ret =
ImGuiNative.
igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
8032 int labelByteCount = 0;
8035 labelByteCount = Encoding.UTF8.GetByteCount(label);
8042 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8043 nativeLabel = nativeLabelStackBytes;
8046 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8047 nativeLabel[nativeLabelOffset] = 0;
8054 void* nativePData = pData.ToPointer();
8055 float vSpeed = 1.0f;
8058 byte* nativeFormat =
null;
8060 byte ret =
ImGuiNative.
igDragScalar(nativeLabel, dataType, nativePData, vSpeed, pMin, pMax, nativeFormat, flags);
8080 int labelByteCount = 0;
8083 labelByteCount = Encoding.UTF8.GetByteCount(label);
8090 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8091 nativeLabel = nativeLabelStackBytes;
8094 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8095 nativeLabel[nativeLabelOffset] = 0;
8102 void* nativePData = pData.ToPointer();
8105 byte* nativeFormat =
null;
8107 byte ret =
ImGuiNative.
igDragScalar(nativeLabel, dataType, nativePData, vSpeed, pMin, pMax, nativeFormat, flags);
8128 int labelByteCount = 0;
8131 labelByteCount = Encoding.UTF8.GetByteCount(label);
8138 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8139 nativeLabel = nativeLabelStackBytes;
8142 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8143 nativeLabel[nativeLabelOffset] = 0;
8150 void* nativePData = pData.ToPointer();
8151 void* nativePMin = pMin.ToPointer();
8153 byte* nativeFormat =
null;
8155 byte ret =
ImGuiNative.
igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, pMax, nativeFormat, flags);
8177 int labelByteCount = 0;
8180 labelByteCount = Encoding.UTF8.GetByteCount(label);
8187 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8188 nativeLabel = nativeLabelStackBytes;
8191 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8192 nativeLabel[nativeLabelOffset] = 0;
8199 void* nativePData = pData.ToPointer();
8200 void* nativePMin = pMin.ToPointer();
8201 void* nativePMax = pMax.ToPointer();
8202 byte* nativeFormat =
null;
8204 byte ret =
ImGuiNative.
igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8224 public static bool DragScalar(
string label,
ImGuiDataType dataType, IntPtr pData,
float vSpeed, IntPtr pMin, IntPtr pMax,
string format)
8227 int labelByteCount = 0;
8230 labelByteCount = Encoding.UTF8.GetByteCount(label);
8237 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8238 nativeLabel = nativeLabelStackBytes;
8241 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8242 nativeLabel[nativeLabelOffset] = 0;
8249 void* nativePData = pData.ToPointer();
8250 void* nativePMin = pMin.ToPointer();
8251 void* nativePMax = pMax.ToPointer();
8253 int formatByteCount = 0;
8256 formatByteCount = Encoding.UTF8.GetByteCount(format);
8263 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
8264 nativeFormat = nativeFormatStackBytes;
8267 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
8268 nativeFormat[nativeFormatOffset] = 0;
8272 nativeFormat =
null;
8276 byte ret =
ImGuiNative.
igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8305 int labelByteCount = 0;
8308 labelByteCount = Encoding.UTF8.GetByteCount(label);
8315 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8316 nativeLabel = nativeLabelStackBytes;
8319 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8320 nativeLabel[nativeLabelOffset] = 0;
8327 void* nativePData = pData.ToPointer();
8328 void* nativePMin = pMin.ToPointer();
8329 void* nativePMax = pMax.ToPointer();
8331 int formatByteCount = 0;
8334 formatByteCount = Encoding.UTF8.GetByteCount(format);
8341 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
8342 nativeFormat = nativeFormatStackBytes;
8345 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
8346 nativeFormat[nativeFormatOffset] = 0;
8350 nativeFormat =
null;
8353 byte ret =
ImGuiNative.
igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8378 int labelByteCount = 0;
8381 labelByteCount = Encoding.UTF8.GetByteCount(label);
8388 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8389 nativeLabel = nativeLabelStackBytes;
8392 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8393 nativeLabel[nativeLabelOffset] = 0;
8400 void* nativePData = pData.ToPointer();
8401 float vSpeed = 1.0f;
8404 byte* nativeFormat =
null;
8406 byte ret =
ImGuiNative.
igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, pMin, pMax, nativeFormat, flags);
8427 int labelByteCount = 0;
8430 labelByteCount = Encoding.UTF8.GetByteCount(label);
8437 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8438 nativeLabel = nativeLabelStackBytes;
8441 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8442 nativeLabel[nativeLabelOffset] = 0;
8449 void* nativePData = pData.ToPointer();
8452 byte* nativeFormat =
null;
8454 byte ret =
ImGuiNative.
igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, pMin, pMax, nativeFormat, flags);
8476 int labelByteCount = 0;
8479 labelByteCount = Encoding.UTF8.GetByteCount(label);
8486 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8487 nativeLabel = nativeLabelStackBytes;
8490 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8491 nativeLabel[nativeLabelOffset] = 0;
8498 void* nativePData = pData.ToPointer();
8499 void* nativePMin = pMin.ToPointer();
8501 byte* nativeFormat =
null;
8503 byte ret =
ImGuiNative.
igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, pMax, nativeFormat, flags);
8523 public static bool DragScalarN(
string label,
ImGuiDataType dataType, IntPtr pData,
int components,
float vSpeed, IntPtr pMin, IntPtr pMax)
8526 int labelByteCount = 0;
8529 labelByteCount = Encoding.UTF8.GetByteCount(label);
8536 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8537 nativeLabel = nativeLabelStackBytes;
8540 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8541 nativeLabel[nativeLabelOffset] = 0;
8548 void* nativePData = pData.ToPointer();
8549 void* nativePMin = pMin.ToPointer();
8550 void* nativePMax = pMax.ToPointer();
8551 byte* nativeFormat =
null;
8553 byte ret =
ImGuiNative.
igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8574 public static bool DragScalarN(
string label,
ImGuiDataType dataType, IntPtr pData,
int components,
float vSpeed, IntPtr pMin, IntPtr pMax,
string format)
8577 int labelByteCount = 0;
8580 labelByteCount = Encoding.UTF8.GetByteCount(label);
8587 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8588 nativeLabel = nativeLabelStackBytes;
8591 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8592 nativeLabel[nativeLabelOffset] = 0;
8599 void* nativePData = pData.ToPointer();
8600 void* nativePMin = pMin.ToPointer();
8601 void* nativePMax = pMax.ToPointer();
8603 int formatByteCount = 0;
8606 formatByteCount = Encoding.UTF8.GetByteCount(format);
8613 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
8614 nativeFormat = nativeFormatStackBytes;
8617 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
8618 nativeFormat[nativeFormatOffset] = 0;
8622 nativeFormat =
null;
8626 byte ret =
ImGuiNative.
igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8656 int labelByteCount = 0;
8659 labelByteCount = Encoding.UTF8.GetByteCount(label);
8666 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
8667 nativeLabel = nativeLabelStackBytes;
8670 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
8671 nativeLabel[nativeLabelOffset] = 0;
8678 void* nativePData = pData.ToPointer();
8679 void* nativePMin = pMin.ToPointer();
8680 void* nativePMax = pMax.ToPointer();
8682 int formatByteCount = 0;
8685 formatByteCount = Encoding.UTF8.GetByteCount(format);
8692 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
8693 nativeFormat = nativeFormatStackBytes;
8696 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
8697 nativeFormat[nativeFormatOffset] = 0;
8701 nativeFormat =
null;
8704 byte ret =
ImGuiNative.
igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8889 void* nativePlatformHandle = platformHandle.ToPointer();
8902 fixed (IntPtr* nativePAllocFunc = &pAllocFunc)
8904 fixed (IntPtr* nativePFreeFunc = &pFreeFunc)
8906 fixed (
void** nativePUserData = &pUserData)
8953 float alphaMul = 1.0f;
9008 int columnIndex = -1;
9040 int columnIndex = -1;
9262 int strIdByteCount = 0;
9265 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9272 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
9273 nativeStrId = nativeStrIdStackBytes;
9276 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
9277 nativeStrId[nativeStrIdOffset] = 0;
9300 void* nativePtrId = ptrId.ToPointer();
9432 float lockThreshold = -1.0f;
9445 float lockThreshold = -1.0f;
9811 int strIdByteCount = 0;
9814 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9821 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
9822 nativeStrId = nativeStrIdStackBytes;
9825 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
9826 nativeStrId[nativeStrIdOffset] = 0;
9857 int strIdByteCount = 0;
9860 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9867 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
9868 nativeStrId = nativeStrIdStackBytes;
9871 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
9872 nativeStrId[nativeStrIdOffset] = 0;
9903 int strIdByteCount = 0;
9906 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9913 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
9914 nativeStrId = nativeStrIdStackBytes;
9917 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
9918 nativeStrId[nativeStrIdOffset] = 0;
9949 int strIdByteCount = 0;
9952 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9959 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
9960 nativeStrId = nativeStrIdStackBytes;
9963 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
9964 nativeStrId[nativeStrIdOffset] = 0;
9995 int strIdByteCount = 0;
9998 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
10005 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
10006 nativeStrId = nativeStrIdStackBytes;
10009 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
10010 nativeStrId[nativeStrIdOffset] = 0;
10014 nativeStrId =
null;
10031 float indentW = 0.0f;
10053 int labelByteCount = 0;
10056 labelByteCount = Encoding.UTF8.GetByteCount(label);
10063 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10064 nativeLabel = nativeLabelStackBytes;
10067 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10068 nativeLabel[nativeLabelOffset] = 0;
10072 nativeLabel =
null;
10076 double stepFast = 0.0;
10077 byte* nativeFormat;
10078 int formatByteCount = 0;
10079 formatByteCount = Encoding.UTF8.GetByteCount(
"%.6f");
10086 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10087 nativeFormat = nativeFormatStackBytes;
10090 int nativeFormatOffset =
Util.
GetUtf8(
"%.6f", nativeFormat, formatByteCount);
10091 nativeFormat[nativeFormatOffset] = 0;
10093 fixed (
double* nativeV = &v)
10120 int labelByteCount = 0;
10123 labelByteCount = Encoding.UTF8.GetByteCount(label);
10130 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10131 nativeLabel = nativeLabelStackBytes;
10134 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10135 nativeLabel[nativeLabelOffset] = 0;
10139 nativeLabel =
null;
10142 double stepFast = 0.0;
10143 byte* nativeFormat;
10144 int formatByteCount = 0;
10145 formatByteCount = Encoding.UTF8.GetByteCount(
"%.6f");
10152 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10153 nativeFormat = nativeFormatStackBytes;
10156 int nativeFormatOffset =
Util.
GetUtf8(
"%.6f", nativeFormat, formatByteCount);
10157 nativeFormat[nativeFormatOffset] = 0;
10159 fixed (
double* nativeV = &v)
10184 public static bool InputDouble(
string label, ref
double v,
double step,
double stepFast)
10187 int labelByteCount = 0;
10190 labelByteCount = Encoding.UTF8.GetByteCount(label);
10197 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10198 nativeLabel = nativeLabelStackBytes;
10201 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10202 nativeLabel[nativeLabelOffset] = 0;
10206 nativeLabel =
null;
10209 byte* nativeFormat;
10210 int formatByteCount = 0;
10211 formatByteCount = Encoding.UTF8.GetByteCount(
"%.6f");
10218 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10219 nativeFormat = nativeFormatStackBytes;
10222 int nativeFormatOffset =
Util.
GetUtf8(
"%.6f", nativeFormat, formatByteCount);
10223 nativeFormat[nativeFormatOffset] = 0;
10225 fixed (
double* nativeV = &v)
10251 public static bool InputDouble(
string label, ref
double v,
double step,
double stepFast,
string format)
10254 int labelByteCount = 0;
10257 labelByteCount = Encoding.UTF8.GetByteCount(label);
10264 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10265 nativeLabel = nativeLabelStackBytes;
10268 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10269 nativeLabel[nativeLabelOffset] = 0;
10273 nativeLabel =
null;
10276 byte* nativeFormat;
10277 int formatByteCount = 0;
10278 if (format !=
null)
10280 formatByteCount = Encoding.UTF8.GetByteCount(format);
10287 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10288 nativeFormat = nativeFormatStackBytes;
10291 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
10292 nativeFormat[nativeFormatOffset] = 0;
10296 nativeFormat =
null;
10300 fixed (
double* nativeV = &v)
10330 int labelByteCount = 0;
10333 labelByteCount = Encoding.UTF8.GetByteCount(label);
10340 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10341 nativeLabel = nativeLabelStackBytes;
10344 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10345 nativeLabel[nativeLabelOffset] = 0;
10349 nativeLabel =
null;
10352 byte* nativeFormat;
10353 int formatByteCount = 0;
10354 if (format !=
null)
10356 formatByteCount = Encoding.UTF8.GetByteCount(format);
10363 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10364 nativeFormat = nativeFormatStackBytes;
10367 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
10368 nativeFormat[nativeFormatOffset] = 0;
10372 nativeFormat =
null;
10375 fixed (
double* nativeV = &v)
10401 int labelByteCount = 0;
10404 labelByteCount = Encoding.UTF8.GetByteCount(label);
10411 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10412 nativeLabel = nativeLabelStackBytes;
10415 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10416 nativeLabel[nativeLabelOffset] = 0;
10420 nativeLabel =
null;
10424 float stepFast = 0.0f;
10425 byte* nativeFormat;
10426 int formatByteCount = 0;
10427 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
10434 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10435 nativeFormat = nativeFormatStackBytes;
10438 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
10439 nativeFormat[nativeFormatOffset] = 0;
10441 fixed (
float* nativeV = &v)
10468 int labelByteCount = 0;
10471 labelByteCount = Encoding.UTF8.GetByteCount(label);
10478 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10479 nativeLabel = nativeLabelStackBytes;
10482 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10483 nativeLabel[nativeLabelOffset] = 0;
10487 nativeLabel =
null;
10490 float stepFast = 0.0f;
10491 byte* nativeFormat;
10492 int formatByteCount = 0;
10493 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
10500 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10501 nativeFormat = nativeFormatStackBytes;
10504 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
10505 nativeFormat[nativeFormatOffset] = 0;
10507 fixed (
float* nativeV = &v)
10532 public static bool InputFloat(
string label, ref
float v,
float step,
float stepFast)
10535 int labelByteCount = 0;
10538 labelByteCount = Encoding.UTF8.GetByteCount(label);
10545 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10546 nativeLabel = nativeLabelStackBytes;
10549 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10550 nativeLabel[nativeLabelOffset] = 0;
10554 nativeLabel =
null;
10557 byte* nativeFormat;
10558 int formatByteCount = 0;
10559 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
10566 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10567 nativeFormat = nativeFormatStackBytes;
10570 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
10571 nativeFormat[nativeFormatOffset] = 0;
10573 fixed (
float* nativeV = &v)
10599 public static bool InputFloat(
string label, ref
float v,
float step,
float stepFast,
string format)
10602 int labelByteCount = 0;
10605 labelByteCount = Encoding.UTF8.GetByteCount(label);
10612 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10613 nativeLabel = nativeLabelStackBytes;
10616 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10617 nativeLabel[nativeLabelOffset] = 0;
10621 nativeLabel =
null;
10624 byte* nativeFormat;
10625 int formatByteCount = 0;
10626 if (format !=
null)
10628 formatByteCount = Encoding.UTF8.GetByteCount(format);
10635 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10636 nativeFormat = nativeFormatStackBytes;
10639 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
10640 nativeFormat[nativeFormatOffset] = 0;
10644 nativeFormat =
null;
10648 fixed (
float* nativeV = &v)
10678 int labelByteCount = 0;
10681 labelByteCount = Encoding.UTF8.GetByteCount(label);
10688 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10689 nativeLabel = nativeLabelStackBytes;
10692 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10693 nativeLabel[nativeLabelOffset] = 0;
10697 nativeLabel =
null;
10700 byte* nativeFormat;
10701 int formatByteCount = 0;
10702 if (format !=
null)
10704 formatByteCount = Encoding.UTF8.GetByteCount(format);
10711 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10712 nativeFormat = nativeFormatStackBytes;
10715 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
10716 nativeFormat[nativeFormatOffset] = 0;
10720 nativeFormat =
null;
10723 fixed (
float* nativeV = &v)
10749 int labelByteCount = 0;
10752 labelByteCount = Encoding.UTF8.GetByteCount(label);
10759 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10760 nativeLabel = nativeLabelStackBytes;
10763 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10764 nativeLabel[nativeLabelOffset] = 0;
10768 nativeLabel =
null;
10771 byte* nativeFormat;
10772 int formatByteCount = 0;
10773 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
10780 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10781 nativeFormat = nativeFormatStackBytes;
10784 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
10785 nativeFormat[nativeFormatOffset] = 0;
10814 int labelByteCount = 0;
10817 labelByteCount = Encoding.UTF8.GetByteCount(label);
10824 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10825 nativeLabel = nativeLabelStackBytes;
10828 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10829 nativeLabel[nativeLabelOffset] = 0;
10833 nativeLabel =
null;
10836 byte* nativeFormat;
10837 int formatByteCount = 0;
10838 if (format !=
null)
10840 formatByteCount = Encoding.UTF8.GetByteCount(format);
10847 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10848 nativeFormat = nativeFormatStackBytes;
10851 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
10852 nativeFormat[nativeFormatOffset] = 0;
10856 nativeFormat =
null;
10888 int labelByteCount = 0;
10891 labelByteCount = Encoding.UTF8.GetByteCount(label);
10898 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10899 nativeLabel = nativeLabelStackBytes;
10902 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10903 nativeLabel[nativeLabelOffset] = 0;
10907 nativeLabel =
null;
10910 byte* nativeFormat;
10911 int formatByteCount = 0;
10912 if (format !=
null)
10914 formatByteCount = Encoding.UTF8.GetByteCount(format);
10921 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10922 nativeFormat = nativeFormatStackBytes;
10925 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
10926 nativeFormat[nativeFormatOffset] = 0;
10930 nativeFormat =
null;
10959 int labelByteCount = 0;
10962 labelByteCount = Encoding.UTF8.GetByteCount(label);
10969 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
10970 nativeLabel = nativeLabelStackBytes;
10973 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
10974 nativeLabel[nativeLabelOffset] = 0;
10978 nativeLabel =
null;
10981 byte* nativeFormat;
10982 int formatByteCount = 0;
10983 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
10990 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
10991 nativeFormat = nativeFormatStackBytes;
10994 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
10995 nativeFormat[nativeFormatOffset] = 0;
11024 int labelByteCount = 0;
11027 labelByteCount = Encoding.UTF8.GetByteCount(label);
11034 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11035 nativeLabel = nativeLabelStackBytes;
11038 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11039 nativeLabel[nativeLabelOffset] = 0;
11043 nativeLabel =
null;
11046 byte* nativeFormat;
11047 int formatByteCount = 0;
11048 if (format !=
null)
11050 formatByteCount = Encoding.UTF8.GetByteCount(format);
11057 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
11058 nativeFormat = nativeFormatStackBytes;
11061 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
11062 nativeFormat[nativeFormatOffset] = 0;
11066 nativeFormat =
null;
11098 int labelByteCount = 0;
11101 labelByteCount = Encoding.UTF8.GetByteCount(label);
11108 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11109 nativeLabel = nativeLabelStackBytes;
11112 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11113 nativeLabel[nativeLabelOffset] = 0;
11117 nativeLabel =
null;
11120 byte* nativeFormat;
11121 int formatByteCount = 0;
11122 if (format !=
null)
11124 formatByteCount = Encoding.UTF8.GetByteCount(format);
11131 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
11132 nativeFormat = nativeFormatStackBytes;
11135 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
11136 nativeFormat[nativeFormatOffset] = 0;
11140 nativeFormat =
null;
11169 int labelByteCount = 0;
11172 labelByteCount = Encoding.UTF8.GetByteCount(label);
11179 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11180 nativeLabel = nativeLabelStackBytes;
11183 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11184 nativeLabel[nativeLabelOffset] = 0;
11188 nativeLabel =
null;
11191 byte* nativeFormat;
11192 int formatByteCount = 0;
11193 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
11200 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
11201 nativeFormat = nativeFormatStackBytes;
11204 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
11205 nativeFormat[nativeFormatOffset] = 0;
11234 int labelByteCount = 0;
11237 labelByteCount = Encoding.UTF8.GetByteCount(label);
11244 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11245 nativeLabel = nativeLabelStackBytes;
11248 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11249 nativeLabel[nativeLabelOffset] = 0;
11253 nativeLabel =
null;
11256 byte* nativeFormat;
11257 int formatByteCount = 0;
11258 if (format !=
null)
11260 formatByteCount = Encoding.UTF8.GetByteCount(format);
11267 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
11268 nativeFormat = nativeFormatStackBytes;
11271 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
11272 nativeFormat[nativeFormatOffset] = 0;
11276 nativeFormat =
null;
11308 int labelByteCount = 0;
11311 labelByteCount = Encoding.UTF8.GetByteCount(label);
11318 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11319 nativeLabel = nativeLabelStackBytes;
11322 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11323 nativeLabel[nativeLabelOffset] = 0;
11327 nativeLabel =
null;
11330 byte* nativeFormat;
11331 int formatByteCount = 0;
11332 if (format !=
null)
11334 formatByteCount = Encoding.UTF8.GetByteCount(format);
11341 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
11342 nativeFormat = nativeFormatStackBytes;
11345 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
11346 nativeFormat[nativeFormatOffset] = 0;
11350 nativeFormat =
null;
11379 int labelByteCount = 0;
11382 labelByteCount = Encoding.UTF8.GetByteCount(label);
11389 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11390 nativeLabel = nativeLabelStackBytes;
11393 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11394 nativeLabel[nativeLabelOffset] = 0;
11398 nativeLabel =
null;
11402 int stepFast = 100;
11404 fixed (
int* nativeV = &v)
11423 public static bool InputInt(
string label, ref
int v,
int step)
11426 int labelByteCount = 0;
11429 labelByteCount = Encoding.UTF8.GetByteCount(label);
11436 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11437 nativeLabel = nativeLabelStackBytes;
11440 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11441 nativeLabel[nativeLabelOffset] = 0;
11445 nativeLabel =
null;
11448 int stepFast = 100;
11450 fixed (
int* nativeV = &v)
11470 public static bool InputInt(
string label, ref
int v,
int step,
int stepFast)
11473 int labelByteCount = 0;
11476 labelByteCount = Encoding.UTF8.GetByteCount(label);
11483 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11484 nativeLabel = nativeLabelStackBytes;
11487 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11488 nativeLabel[nativeLabelOffset] = 0;
11492 nativeLabel =
null;
11496 fixed (
int* nativeV = &v)
11520 int labelByteCount = 0;
11523 labelByteCount = Encoding.UTF8.GetByteCount(label);
11530 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11531 nativeLabel = nativeLabelStackBytes;
11534 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11535 nativeLabel[nativeLabelOffset] = 0;
11539 nativeLabel =
null;
11542 fixed (
int* nativeV = &v)
11563 int labelByteCount = 0;
11566 labelByteCount = Encoding.UTF8.GetByteCount(label);
11573 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11574 nativeLabel = nativeLabelStackBytes;
11577 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11578 nativeLabel[nativeLabelOffset] = 0;
11582 nativeLabel =
null;
11586 fixed (
int* nativeV = &v)
11608 int labelByteCount = 0;
11611 labelByteCount = Encoding.UTF8.GetByteCount(label);
11618 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11619 nativeLabel = nativeLabelStackBytes;
11622 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11623 nativeLabel[nativeLabelOffset] = 0;
11627 nativeLabel =
null;
11630 fixed (
int* nativeV = &v)
11651 int labelByteCount = 0;
11654 labelByteCount = Encoding.UTF8.GetByteCount(label);
11661 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11662 nativeLabel = nativeLabelStackBytes;
11665 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11666 nativeLabel[nativeLabelOffset] = 0;
11670 nativeLabel =
null;
11674 fixed (
int* nativeV = &v)
11696 int labelByteCount = 0;
11699 labelByteCount = Encoding.UTF8.GetByteCount(label);
11706 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11707 nativeLabel = nativeLabelStackBytes;
11710 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11711 nativeLabel[nativeLabelOffset] = 0;
11715 nativeLabel =
null;
11718 fixed (
int* nativeV = &v)
11739 int labelByteCount = 0;
11742 labelByteCount = Encoding.UTF8.GetByteCount(label);
11749 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11750 nativeLabel = nativeLabelStackBytes;
11753 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11754 nativeLabel[nativeLabelOffset] = 0;
11758 nativeLabel =
null;
11762 fixed (
int* nativeV = &v)
11784 int labelByteCount = 0;
11787 labelByteCount = Encoding.UTF8.GetByteCount(label);
11794 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11795 nativeLabel = nativeLabelStackBytes;
11798 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11799 nativeLabel[nativeLabelOffset] = 0;
11803 nativeLabel =
null;
11806 fixed (
int* nativeV = &v)
11828 int labelByteCount = 0;
11831 labelByteCount = Encoding.UTF8.GetByteCount(label);
11838 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11839 nativeLabel = nativeLabelStackBytes;
11842 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11843 nativeLabel[nativeLabelOffset] = 0;
11847 nativeLabel =
null;
11850 void* nativePData = pData.ToPointer();
11851 void* pStep =
null;
11852 void* pStepFast =
null;
11853 byte* nativeFormat =
null;
11875 int labelByteCount = 0;
11878 labelByteCount = Encoding.UTF8.GetByteCount(label);
11885 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11886 nativeLabel = nativeLabelStackBytes;
11889 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11890 nativeLabel[nativeLabelOffset] = 0;
11894 nativeLabel =
null;
11897 void* nativePData = pData.ToPointer();
11898 void* nativePStep = pStep.ToPointer();
11899 void* pStepFast =
null;
11900 byte* nativeFormat =
null;
11902 byte ret =
ImGuiNative.
igInputScalar(nativeLabel, dataType, nativePData, nativePStep, pStepFast, nativeFormat, flags);
11923 int labelByteCount = 0;
11926 labelByteCount = Encoding.UTF8.GetByteCount(label);
11933 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11934 nativeLabel = nativeLabelStackBytes;
11937 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11938 nativeLabel[nativeLabelOffset] = 0;
11942 nativeLabel =
null;
11945 void* nativePData = pData.ToPointer();
11946 void* nativePStep = pStep.ToPointer();
11947 void* nativePStepFast = pStepFast.ToPointer();
11948 byte* nativeFormat =
null;
11950 byte ret =
ImGuiNative.
igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flags);
11972 int labelByteCount = 0;
11975 labelByteCount = Encoding.UTF8.GetByteCount(label);
11982 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
11983 nativeLabel = nativeLabelStackBytes;
11986 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
11987 nativeLabel[nativeLabelOffset] = 0;
11991 nativeLabel =
null;
11994 void* nativePData = pData.ToPointer();
11995 void* nativePStep = pStep.ToPointer();
11996 void* nativePStepFast = pStepFast.ToPointer();
11997 byte* nativeFormat;
11998 int formatByteCount = 0;
11999 if (format !=
null)
12001 formatByteCount = Encoding.UTF8.GetByteCount(format);
12008 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
12009 nativeFormat = nativeFormatStackBytes;
12012 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
12013 nativeFormat[nativeFormatOffset] = 0;
12017 nativeFormat =
null;
12021 byte ret =
ImGuiNative.
igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flags);
12049 int labelByteCount = 0;
12052 labelByteCount = Encoding.UTF8.GetByteCount(label);
12059 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
12060 nativeLabel = nativeLabelStackBytes;
12063 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
12064 nativeLabel[nativeLabelOffset] = 0;
12068 nativeLabel =
null;
12071 void* nativePData = pData.ToPointer();
12072 void* nativePStep = pStep.ToPointer();
12073 void* nativePStepFast = pStepFast.ToPointer();
12074 byte* nativeFormat;
12075 int formatByteCount = 0;
12076 if (format !=
null)
12078 formatByteCount = Encoding.UTF8.GetByteCount(format);
12085 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
12086 nativeFormat = nativeFormatStackBytes;
12089 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
12090 nativeFormat[nativeFormatOffset] = 0;
12094 nativeFormat =
null;
12097 byte ret =
ImGuiNative.
igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flags);
12122 int labelByteCount = 0;
12125 labelByteCount = Encoding.UTF8.GetByteCount(label);
12132 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
12133 nativeLabel = nativeLabelStackBytes;
12136 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
12137 nativeLabel[nativeLabelOffset] = 0;
12141 nativeLabel =
null;
12144 void* nativePData = pData.ToPointer();
12145 void* pStep =
null;
12146 void* pStepFast =
null;
12147 byte* nativeFormat =
null;
12149 byte ret =
ImGuiNative.
igInputScalarN(nativeLabel, dataType, nativePData, components, pStep, pStepFast, nativeFormat, flags);
12170 int labelByteCount = 0;
12173 labelByteCount = Encoding.UTF8.GetByteCount(label);
12180 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
12181 nativeLabel = nativeLabelStackBytes;
12184 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
12185 nativeLabel[nativeLabelOffset] = 0;
12189 nativeLabel =
null;
12192 void* nativePData = pData.ToPointer();
12193 void* nativePStep = pStep.ToPointer();
12194 void* pStepFast =
null;
12195 byte* nativeFormat =
null;
12197 byte ret =
ImGuiNative.
igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, pStepFast, nativeFormat, flags);
12219 int labelByteCount = 0;
12222 labelByteCount = Encoding.UTF8.GetByteCount(label);
12229 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
12230 nativeLabel = nativeLabelStackBytes;
12233 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
12234 nativeLabel[nativeLabelOffset] = 0;
12238 nativeLabel =
null;
12241 void* nativePData = pData.ToPointer();
12242 void* nativePStep = pStep.ToPointer();
12243 void* nativePStepFast = pStepFast.ToPointer();
12244 byte* nativeFormat =
null;
12246 byte ret =
ImGuiNative.
igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flags);
12266 public static bool InputScalarN(
string label,
ImGuiDataType dataType, IntPtr pData,
int components, IntPtr pStep, IntPtr pStepFast,
string format)
12269 int labelByteCount = 0;
12272 labelByteCount = Encoding.UTF8.GetByteCount(label);
12279 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
12280 nativeLabel = nativeLabelStackBytes;
12283 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
12284 nativeLabel[nativeLabelOffset] = 0;
12288 nativeLabel =
null;
12291 void* nativePData = pData.ToPointer();
12292 void* nativePStep = pStep.ToPointer();
12293 void* nativePStepFast = pStepFast.ToPointer();
12294 byte* nativeFormat;
12295 int formatByteCount = 0;
12296 if (format !=
null)
12298 formatByteCount = Encoding.UTF8.GetByteCount(format);
12305 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
12306 nativeFormat = nativeFormatStackBytes;
12309 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
12310 nativeFormat[nativeFormatOffset] = 0;
12314 nativeFormat =
null;
12318 byte ret =
ImGuiNative.
igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flags);
12347 int labelByteCount = 0;
12350 labelByteCount = Encoding.UTF8.GetByteCount(label);
12357 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
12358 nativeLabel = nativeLabelStackBytes;
12361 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
12362 nativeLabel[nativeLabelOffset] = 0;
12366 nativeLabel =
null;
12369 void* nativePData = pData.ToPointer();
12370 void* nativePStep = pStep.ToPointer();
12371 void* nativePStepFast = pStepFast.ToPointer();
12372 byte* nativeFormat;
12373 int formatByteCount = 0;
12374 if (format !=
null)
12376 formatByteCount = Encoding.UTF8.GetByteCount(format);
12383 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
12384 nativeFormat = nativeFormatStackBytes;
12387 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
12388 nativeFormat[nativeFormatOffset] = 0;
12392 nativeFormat =
null;
12395 byte ret =
ImGuiNative.
igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flags);
12418 int strIdByteCount = 0;
12421 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12428 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
12429 nativeStrId = nativeStrIdStackBytes;
12432 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
12433 nativeStrId[nativeStrIdOffset] = 0;
12437 nativeStrId =
null;
12460 int strIdByteCount = 0;
12463 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12470 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
12471 nativeStrId = nativeStrIdStackBytes;
12474 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
12475 nativeStrId[nativeStrIdOffset] = 0;
12479 nativeStrId =
null;
12686 byte nativeRepeat = repeat ? (byte) 1 : (
byte) 0;
12722 byte nativeRepeat = repeat ? (byte) 1 : (
byte) 0;
12756 float lockThreshold = -1.0f;
12795 byte nativeClip = clip ? (byte) 1 : (
byte) 0;
12818 fixed (
Vector2F* nativeMousePos = &mousePos)
12844 int strIdByteCount = 0;
12847 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12854 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
12855 nativeStrId = nativeStrIdStackBytes;
12858 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
12859 nativeStrId[nativeStrIdOffset] = 0;
12863 nativeStrId =
null;
12885 int strIdByteCount = 0;
12888 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12895 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
12896 nativeStrId = nativeStrIdStackBytes;
12899 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
12900 nativeStrId[nativeStrIdOffset] = 0;
12904 nativeStrId =
null;
13021 int labelByteCount = 0;
13024 labelByteCount = Encoding.UTF8.GetByteCount(label);
13031 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13032 nativeLabel = nativeLabelStackBytes;
13035 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13036 nativeLabel[nativeLabelOffset] = 0;
13040 nativeLabel =
null;
13044 int fmtByteCount = 0;
13047 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
13054 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
13055 nativeFmt = nativeFmtStackBytes;
13058 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
13059 nativeFmt[nativeFmtOffset] = 0;
13086 public static bool ListBox(
string label, ref
int currentItem,
string[] items,
int itemsCount)
13089 int labelByteCount = 0;
13092 labelByteCount = Encoding.UTF8.GetByteCount(label);
13099 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13100 nativeLabel = nativeLabelStackBytes;
13103 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13104 nativeLabel[nativeLabelOffset] = 0;
13108 nativeLabel =
null;
13111 int* itemsByteCounts = stackalloc
int[items.Length];
13112 int itemsByteCount = 0;
13113 for (
int i = 0; i < items.Length; i++)
13115 string s = items[i];
13116 itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
13117 itemsByteCount += itemsByteCounts[i] + 1;
13120 byte* nativeItemsData = stackalloc
byte[itemsByteCount];
13122 for (
int i = 0; i < items.Length; i++)
13124 string s = items[i];
13125 fixed (
char* sPtr = s)
13127 offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
13128 nativeItemsData[offset] = 0;
13133 byte** nativeItems = stackalloc
byte*[items.Length];
13135 for (
int i = 0; i < items.Length; i++)
13137 nativeItems[i] = &nativeItemsData[offset];
13138 offset += itemsByteCounts[i] + 1;
13141 int heightInItems = -1;
13142 fixed (
int* nativeCurrentItem = ¤tItem)
13163 public static bool ListBox(
string label, ref
int currentItem,
string[] items,
int itemsCount,
int heightInItems)
13166 int labelByteCount = 0;
13169 labelByteCount = Encoding.UTF8.GetByteCount(label);
13176 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13177 nativeLabel = nativeLabelStackBytes;
13180 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13181 nativeLabel[nativeLabelOffset] = 0;
13185 nativeLabel =
null;
13188 int* itemsByteCounts = stackalloc
int[items.Length];
13189 int itemsByteCount = 0;
13190 for (
int i = 0; i < items.Length; i++)
13192 string s = items[i];
13193 itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
13194 itemsByteCount += itemsByteCounts[i] + 1;
13197 byte* nativeItemsData = stackalloc
byte[itemsByteCount];
13199 for (
int i = 0; i < items.Length; i++)
13201 string s = items[i];
13202 fixed (
char* sPtr = s)
13204 offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
13205 nativeItemsData[offset] = 0;
13210 byte** nativeItems = stackalloc
byte*[items.Length];
13212 for (
int i = 0; i < items.Length; i++)
13214 nativeItems[i] = &nativeItemsData[offset];
13215 offset += itemsByteCounts[i] + 1;
13218 fixed (
int* nativeCurrentItem = ¤tItem)
13236 byte* nativeIniFilename;
13237 int iniFilenameByteCount = 0;
13238 if (iniFilename !=
null)
13240 iniFilenameByteCount = Encoding.UTF8.GetByteCount(iniFilename);
13243 nativeIniFilename =
Util.
Allocate(iniFilenameByteCount + 1);
13247 byte* nativeIniFilenameStackBytes = stackalloc
byte[iniFilenameByteCount + 1];
13248 nativeIniFilename = nativeIniFilenameStackBytes;
13251 int nativeIniFilenameOffset =
Util.
GetUtf8(iniFilename, nativeIniFilename, iniFilenameByteCount);
13252 nativeIniFilename[nativeIniFilenameOffset] = 0;
13256 nativeIniFilename =
null;
13272 byte* nativeIniData;
13273 int iniDataByteCount = 0;
13274 if (iniData !=
null)
13276 iniDataByteCount = Encoding.UTF8.GetByteCount(iniData);
13283 byte* nativeIniDataStackBytes = stackalloc
byte[iniDataByteCount + 1];
13284 nativeIniData = nativeIniDataStackBytes;
13287 int nativeIniDataOffset =
Util.
GetUtf8(iniData, nativeIniData, iniDataByteCount);
13288 nativeIniData[nativeIniDataOffset] = 0;
13292 nativeIniData =
null;
13310 byte* nativeIniData;
13311 int iniDataByteCount = 0;
13312 if (iniData !=
null)
13314 iniDataByteCount = Encoding.UTF8.GetByteCount(iniData);
13321 byte* nativeIniDataStackBytes = stackalloc
byte[iniDataByteCount + 1];
13322 nativeIniData = nativeIniDataStackBytes;
13325 int nativeIniDataOffset =
Util.
GetUtf8(iniData, nativeIniData, iniDataByteCount);
13326 nativeIniData[nativeIniDataOffset] = 0;
13330 nativeIniData =
null;
13363 int fmtByteCount = 0;
13366 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
13373 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
13374 nativeFmt = nativeFmtStackBytes;
13377 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
13378 nativeFmt[nativeFmtOffset] = 0;
13397 int autoOpenDepth = -1;
13415 int autoOpenDepth = -1;
13416 byte* nativeFilename =
null;
13426 byte* nativeFilename =
null;
13435 public static void LogToFile(
int autoOpenDepth,
string filename)
13437 byte* nativeFilename;
13438 int filenameByteCount = 0;
13439 if (filename !=
null)
13441 filenameByteCount = Encoding.UTF8.GetByteCount(filename);
13444 nativeFilename =
Util.
Allocate(filenameByteCount + 1);
13448 byte* nativeFilenameStackBytes = stackalloc
byte[filenameByteCount + 1];
13449 nativeFilename = nativeFilenameStackBytes;
13452 int nativeFilenameOffset =
Util.
GetUtf8(filename, nativeFilename, filenameByteCount);
13453 nativeFilename[nativeFilenameOffset] = 0;
13457 nativeFilename =
null;
13472 int autoOpenDepth = -1;
13493 return (IntPtr) ret;
13502 void* nativePtr = ptr.ToPointer();
13514 int labelByteCount = 0;
13517 labelByteCount = Encoding.UTF8.GetByteCount(label);
13524 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13525 nativeLabel = nativeLabelStackBytes;
13528 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13529 nativeLabel[nativeLabelOffset] = 0;
13533 nativeLabel =
null;
13536 byte* nativeShortcut =
null;
13557 int labelByteCount = 0;
13560 labelByteCount = Encoding.UTF8.GetByteCount(label);
13567 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13568 nativeLabel = nativeLabelStackBytes;
13571 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13572 nativeLabel[nativeLabelOffset] = 0;
13576 nativeLabel =
null;
13579 byte* nativeShortcut;
13580 int shortcutByteCount = 0;
13581 if (shortcut !=
null)
13583 shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13586 nativeShortcut =
Util.
Allocate(shortcutByteCount + 1);
13590 byte* nativeShortcutStackBytes = stackalloc
byte[shortcutByteCount + 1];
13591 nativeShortcut = nativeShortcutStackBytes;
13594 int nativeShortcutOffset =
Util.
GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13595 nativeShortcut[nativeShortcutOffset] = 0;
13599 nativeShortcut =
null;
13625 public static bool MenuItem(
string label,
string shortcut,
bool selected)
13628 int labelByteCount = 0;
13631 labelByteCount = Encoding.UTF8.GetByteCount(label);
13638 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13639 nativeLabel = nativeLabelStackBytes;
13642 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13643 nativeLabel[nativeLabelOffset] = 0;
13647 nativeLabel =
null;
13650 byte* nativeShortcut;
13651 int shortcutByteCount = 0;
13652 if (shortcut !=
null)
13654 shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13657 nativeShortcut =
Util.
Allocate(shortcutByteCount + 1);
13661 byte* nativeShortcutStackBytes = stackalloc
byte[shortcutByteCount + 1];
13662 nativeShortcut = nativeShortcutStackBytes;
13665 int nativeShortcutOffset =
Util.
GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13666 nativeShortcut[nativeShortcutOffset] = 0;
13670 nativeShortcut =
null;
13673 byte nativeSelected = selected ? (byte) 1 : (
byte) 0;
13697 public static bool MenuItem(
string label,
string shortcut,
bool selected,
bool enabled)
13700 int labelByteCount = 0;
13703 labelByteCount = Encoding.UTF8.GetByteCount(label);
13710 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13711 nativeLabel = nativeLabelStackBytes;
13714 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13715 nativeLabel[nativeLabelOffset] = 0;
13719 nativeLabel =
null;
13722 byte* nativeShortcut;
13723 int shortcutByteCount = 0;
13724 if (shortcut !=
null)
13726 shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13729 nativeShortcut =
Util.
Allocate(shortcutByteCount + 1);
13733 byte* nativeShortcutStackBytes = stackalloc
byte[shortcutByteCount + 1];
13734 nativeShortcut = nativeShortcutStackBytes;
13737 int nativeShortcutOffset =
Util.
GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13738 nativeShortcut[nativeShortcutOffset] = 0;
13742 nativeShortcut =
null;
13745 byte nativeSelected = selected ? (byte) 1 : (
byte) 0;
13746 byte nativeEnabled = enabled ? (byte) 1 : (
byte) 0;
13768 public static bool MenuItem(
string label,
string shortcut, ref
bool pSelected)
13771 int labelByteCount = 0;
13774 labelByteCount = Encoding.UTF8.GetByteCount(label);
13781 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13782 nativeLabel = nativeLabelStackBytes;
13785 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13786 nativeLabel[nativeLabelOffset] = 0;
13790 nativeLabel =
null;
13793 byte* nativeShortcut;
13794 int shortcutByteCount = 0;
13795 if (shortcut !=
null)
13797 shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13800 nativeShortcut =
Util.
Allocate(shortcutByteCount + 1);
13804 byte* nativeShortcutStackBytes = stackalloc
byte[shortcutByteCount + 1];
13805 nativeShortcut = nativeShortcutStackBytes;
13808 int nativeShortcutOffset =
Util.
GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13809 nativeShortcut[nativeShortcutOffset] = 0;
13813 nativeShortcut =
null;
13816 byte nativePSelectedVal = pSelected ? (byte) 1 : (
byte) 0;
13817 byte* nativePSelected = &nativePSelectedVal;
13830 pSelected = nativePSelectedVal != 0;
13842 public static bool MenuItem(
string label,
string shortcut, ref
bool pSelected,
bool enabled)
13845 int labelByteCount = 0;
13848 labelByteCount = Encoding.UTF8.GetByteCount(label);
13855 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
13856 nativeLabel = nativeLabelStackBytes;
13859 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
13860 nativeLabel[nativeLabelOffset] = 0;
13864 nativeLabel =
null;
13867 byte* nativeShortcut;
13868 int shortcutByteCount = 0;
13869 if (shortcut !=
null)
13871 shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13874 nativeShortcut =
Util.
Allocate(shortcutByteCount + 1);
13878 byte* nativeShortcutStackBytes = stackalloc
byte[shortcutByteCount + 1];
13879 nativeShortcut = nativeShortcutStackBytes;
13882 int nativeShortcutOffset =
Util.
GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13883 nativeShortcut[nativeShortcutOffset] = 0;
13887 nativeShortcut =
null;
13890 byte nativePSelectedVal = pSelected ? (byte) 1 : (
byte) 0;
13891 byte* nativePSelected = &nativePSelectedVal;
13892 byte nativeEnabled = enabled ? (byte) 1 : (
byte) 0;
13904 pSelected = nativePSelectedVal != 0;
13939 int strIdByteCount = 0;
13942 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
13949 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
13950 nativeStrId = nativeStrIdStackBytes;
13953 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
13954 nativeStrId[nativeStrIdOffset] = 0;
13958 nativeStrId =
null;
13977 int strIdByteCount = 0;
13980 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
13987 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
13988 nativeStrId = nativeStrIdStackBytes;
13991 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
13992 nativeStrId[nativeStrIdOffset] = 0;
13996 nativeStrId =
null;
14031 byte* nativeStrId =
null;
14043 int strIdByteCount = 0;
14046 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
14053 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
14054 nativeStrId = nativeStrIdStackBytes;
14057 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
14058 nativeStrId[nativeStrIdOffset] = 0;
14062 nativeStrId =
null;
14081 int strIdByteCount = 0;
14084 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
14091 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
14092 nativeStrId = nativeStrIdStackBytes;
14095 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
14096 nativeStrId[nativeStrIdOffset] = 0;
14100 nativeStrId =
null;
14119 int labelByteCount = 0;
14122 labelByteCount = Encoding.UTF8.GetByteCount(label);
14129 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14130 nativeLabel = nativeLabelStackBytes;
14133 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14134 nativeLabel[nativeLabelOffset] = 0;
14138 nativeLabel =
null;
14141 int valuesOffset = 0;
14142 byte* nativeOverlayText =
null;
14143 float scaleMin =
float.MaxValue;
14144 float scaleMax =
float.MaxValue;
14146 int stride =
sizeof(float);
14147 fixed (
float* nativeValues = &values)
14164 public static void PlotHistogram(
string label, ref
float values,
int valuesCount,
int valuesOffset)
14167 int labelByteCount = 0;
14170 labelByteCount = Encoding.UTF8.GetByteCount(label);
14177 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14178 nativeLabel = nativeLabelStackBytes;
14181 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14182 nativeLabel[nativeLabelOffset] = 0;
14186 nativeLabel =
null;
14189 byte* nativeOverlayText =
null;
14190 float scaleMin =
float.MaxValue;
14191 float scaleMax =
float.MaxValue;
14193 int stride =
sizeof(float);
14194 fixed (
float* nativeValues = &values)
14212 public static void PlotHistogram(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText)
14215 int labelByteCount = 0;
14218 labelByteCount = Encoding.UTF8.GetByteCount(label);
14225 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14226 nativeLabel = nativeLabelStackBytes;
14229 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14230 nativeLabel[nativeLabelOffset] = 0;
14234 nativeLabel =
null;
14237 byte* nativeOverlayText;
14238 int overlayTextByteCount = 0;
14239 if (overlayText !=
null)
14241 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14244 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14248 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14249 nativeOverlayText = nativeOverlayTextStackBytes;
14252 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14253 nativeOverlayText[nativeOverlayTextOffset] = 0;
14257 nativeOverlayText =
null;
14260 float scaleMin =
float.MaxValue;
14261 float scaleMax =
float.MaxValue;
14263 int stride =
sizeof(float);
14264 fixed (
float* nativeValues = &values)
14288 public static void PlotHistogram(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin)
14291 int labelByteCount = 0;
14294 labelByteCount = Encoding.UTF8.GetByteCount(label);
14301 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14302 nativeLabel = nativeLabelStackBytes;
14305 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14306 nativeLabel[nativeLabelOffset] = 0;
14310 nativeLabel =
null;
14313 byte* nativeOverlayText;
14314 int overlayTextByteCount = 0;
14315 if (overlayText !=
null)
14317 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14320 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14324 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14325 nativeOverlayText = nativeOverlayTextStackBytes;
14328 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14329 nativeOverlayText[nativeOverlayTextOffset] = 0;
14333 nativeOverlayText =
null;
14336 float scaleMax =
float.MaxValue;
14338 int stride =
sizeof(float);
14339 fixed (
float* nativeValues = &values)
14364 public static void PlotHistogram(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin,
float scaleMax)
14367 int labelByteCount = 0;
14370 labelByteCount = Encoding.UTF8.GetByteCount(label);
14377 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14378 nativeLabel = nativeLabelStackBytes;
14381 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14382 nativeLabel[nativeLabelOffset] = 0;
14386 nativeLabel =
null;
14389 byte* nativeOverlayText;
14390 int overlayTextByteCount = 0;
14391 if (overlayText !=
null)
14393 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14396 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14400 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14401 nativeOverlayText = nativeOverlayTextStackBytes;
14404 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14405 nativeOverlayText[nativeOverlayTextOffset] = 0;
14409 nativeOverlayText =
null;
14413 int stride =
sizeof(float);
14414 fixed (
float* nativeValues = &values)
14440 public static void PlotHistogram(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin,
float scaleMax,
Vector2F graphSize)
14443 int labelByteCount = 0;
14446 labelByteCount = Encoding.UTF8.GetByteCount(label);
14453 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14454 nativeLabel = nativeLabelStackBytes;
14457 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14458 nativeLabel[nativeLabelOffset] = 0;
14462 nativeLabel =
null;
14465 byte* nativeOverlayText;
14466 int overlayTextByteCount = 0;
14467 if (overlayText !=
null)
14469 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14472 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14476 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14477 nativeOverlayText = nativeOverlayTextStackBytes;
14480 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14481 nativeOverlayText[nativeOverlayTextOffset] = 0;
14485 nativeOverlayText =
null;
14488 int stride =
sizeof(float);
14489 fixed (
float* nativeValues = &values)
14516 public static void PlotHistogram(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin,
float scaleMax,
Vector2F graphSize,
int stride)
14519 int labelByteCount = 0;
14522 labelByteCount = Encoding.UTF8.GetByteCount(label);
14529 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14530 nativeLabel = nativeLabelStackBytes;
14533 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14534 nativeLabel[nativeLabelOffset] = 0;
14538 nativeLabel =
null;
14541 byte* nativeOverlayText;
14542 int overlayTextByteCount = 0;
14543 if (overlayText !=
null)
14545 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14548 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14552 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14553 nativeOverlayText = nativeOverlayTextStackBytes;
14556 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14557 nativeOverlayText[nativeOverlayTextOffset] = 0;
14561 nativeOverlayText =
null;
14564 fixed (
float* nativeValues = &values)
14585 public static void PlotLines(
string label, ref
float values,
int valuesCount)
14588 int labelByteCount = 0;
14591 labelByteCount = Encoding.UTF8.GetByteCount(label);
14598 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14599 nativeLabel = nativeLabelStackBytes;
14602 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14603 nativeLabel[nativeLabelOffset] = 0;
14607 nativeLabel =
null;
14610 int valuesOffset = 0;
14611 byte* nativeOverlayText =
null;
14612 float scaleMin =
float.MaxValue;
14613 float scaleMax =
float.MaxValue;
14615 int stride =
sizeof(float);
14616 fixed (
float* nativeValues = &values)
14633 public static void PlotLines(
string label, ref
float values,
int valuesCount,
int valuesOffset)
14636 int labelByteCount = 0;
14639 labelByteCount = Encoding.UTF8.GetByteCount(label);
14646 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14647 nativeLabel = nativeLabelStackBytes;
14650 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14651 nativeLabel[nativeLabelOffset] = 0;
14655 nativeLabel =
null;
14658 byte* nativeOverlayText =
null;
14659 float scaleMin =
float.MaxValue;
14660 float scaleMax =
float.MaxValue;
14662 int stride =
sizeof(float);
14663 fixed (
float* nativeValues = &values)
14681 public static void PlotLines(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText)
14684 int labelByteCount = 0;
14687 labelByteCount = Encoding.UTF8.GetByteCount(label);
14694 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14695 nativeLabel = nativeLabelStackBytes;
14698 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14699 nativeLabel[nativeLabelOffset] = 0;
14703 nativeLabel =
null;
14706 byte* nativeOverlayText;
14707 int overlayTextByteCount = 0;
14708 if (overlayText !=
null)
14710 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14713 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14717 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14718 nativeOverlayText = nativeOverlayTextStackBytes;
14721 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14722 nativeOverlayText[nativeOverlayTextOffset] = 0;
14726 nativeOverlayText =
null;
14729 float scaleMin =
float.MaxValue;
14730 float scaleMax =
float.MaxValue;
14732 int stride =
sizeof(float);
14733 fixed (
float* nativeValues = &values)
14757 public static void PlotLines(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin)
14760 int labelByteCount = 0;
14763 labelByteCount = Encoding.UTF8.GetByteCount(label);
14770 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14771 nativeLabel = nativeLabelStackBytes;
14774 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14775 nativeLabel[nativeLabelOffset] = 0;
14779 nativeLabel =
null;
14782 byte* nativeOverlayText;
14783 int overlayTextByteCount = 0;
14784 if (overlayText !=
null)
14786 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14789 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14793 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14794 nativeOverlayText = nativeOverlayTextStackBytes;
14797 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14798 nativeOverlayText[nativeOverlayTextOffset] = 0;
14802 nativeOverlayText =
null;
14805 float scaleMax =
float.MaxValue;
14807 int stride =
sizeof(float);
14808 fixed (
float* nativeValues = &values)
14833 public static void PlotLines(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin,
float scaleMax)
14836 int labelByteCount = 0;
14839 labelByteCount = Encoding.UTF8.GetByteCount(label);
14846 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14847 nativeLabel = nativeLabelStackBytes;
14850 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14851 nativeLabel[nativeLabelOffset] = 0;
14855 nativeLabel =
null;
14858 byte* nativeOverlayText;
14859 int overlayTextByteCount = 0;
14860 if (overlayText !=
null)
14862 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14865 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14869 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14870 nativeOverlayText = nativeOverlayTextStackBytes;
14873 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14874 nativeOverlayText[nativeOverlayTextOffset] = 0;
14878 nativeOverlayText =
null;
14882 int stride =
sizeof(float);
14883 fixed (
float* nativeValues = &values)
14909 public static void PlotLines(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin,
float scaleMax,
Vector2F graphSize)
14912 int labelByteCount = 0;
14915 labelByteCount = Encoding.UTF8.GetByteCount(label);
14922 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14923 nativeLabel = nativeLabelStackBytes;
14926 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
14927 nativeLabel[nativeLabelOffset] = 0;
14931 nativeLabel =
null;
14934 byte* nativeOverlayText;
14935 int overlayTextByteCount = 0;
14936 if (overlayText !=
null)
14938 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14941 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
14945 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
14946 nativeOverlayText = nativeOverlayTextStackBytes;
14949 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14950 nativeOverlayText[nativeOverlayTextOffset] = 0;
14954 nativeOverlayText =
null;
14957 int stride =
sizeof(float);
14958 fixed (
float* nativeValues = &values)
14985 public static void PlotLines(
string label, ref
float values,
int valuesCount,
int valuesOffset,
string overlayText,
float scaleMin,
float scaleMax,
Vector2F graphSize,
int stride)
14988 int labelByteCount = 0;
14991 labelByteCount = Encoding.UTF8.GetByteCount(label);
14998 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
14999 nativeLabel = nativeLabelStackBytes;
15002 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15003 nativeLabel[nativeLabelOffset] = 0;
15007 nativeLabel =
null;
15010 byte* nativeOverlayText;
15011 int overlayTextByteCount = 0;
15012 if (overlayText !=
null)
15014 overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
15017 nativeOverlayText =
Util.
Allocate(overlayTextByteCount + 1);
15021 byte* nativeOverlayTextStackBytes = stackalloc
byte[overlayTextByteCount + 1];
15022 nativeOverlayText = nativeOverlayTextStackBytes;
15025 int nativeOverlayTextOffset =
Util.
GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
15026 nativeOverlayText[nativeOverlayTextOffset] = 0;
15030 nativeOverlayText =
null;
15033 fixed (
float* nativeValues = &values)
15147 byte* nativeOverlay =
null;
15158 byte* nativeOverlay =
null;
15170 byte* nativeOverlay;
15171 int overlayByteCount = 0;
15172 if (overlay !=
null)
15174 overlayByteCount = Encoding.UTF8.GetByteCount(overlay);
15181 byte* nativeOverlayStackBytes = stackalloc
byte[overlayByteCount + 1];
15182 nativeOverlay = nativeOverlayStackBytes;
15185 int nativeOverlayOffset =
Util.
GetUtf8(overlay, nativeOverlay, overlayByteCount);
15186 nativeOverlay[nativeOverlayOffset] = 0;
15190 nativeOverlay =
null;
15206 byte nativeRepeat = repeat ? (byte) 1 : (
byte) 0;
15218 byte nativeIntersectWithCurrentClipRect = intersectWithCurrentClipRect ? (byte) 1 : (
byte) 0;
15239 int strIdByteCount = 0;
15242 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
15249 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
15250 nativeStrId = nativeStrIdStackBytes;
15253 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
15254 nativeStrId[nativeStrIdOffset] = 0;
15258 nativeStrId =
null;
15274 void* nativePtrId = ptrId.ToPointer();
15342 byte nativeTabStop = tabStop ? (byte) 1 : (
byte) 0;
15351 float wrapLocalPosX = 0.0f;
15373 int labelByteCount = 0;
15376 labelByteCount = Encoding.UTF8.GetByteCount(label);
15383 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15384 nativeLabel = nativeLabelStackBytes;
15387 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15388 nativeLabel[nativeLabelOffset] = 0;
15392 nativeLabel =
null;
15395 byte nativeActive = active ? (byte) 1 : (
byte) 0;
15415 int labelByteCount = 0;
15418 labelByteCount = Encoding.UTF8.GetByteCount(label);
15425 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15426 nativeLabel = nativeLabelStackBytes;
15429 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15430 nativeLabel[nativeLabelOffset] = 0;
15434 nativeLabel =
null;
15437 fixed (
int* nativeV = &v)
15462 void* platformRenderArg =
null;
15463 void* rendererRenderArg =
null;
15473 void* nativePlatformRenderArg = platformRenderArg.ToPointer();
15474 void* rendererRenderArg =
null;
15485 void* nativePlatformRenderArg = platformRenderArg.ToPointer();
15486 void* nativeRendererRenderArg = rendererRenderArg.ToPointer();
15513 float offsetFromStartX = 0.0f;
15514 float spacing = -1.0f;
15524 float spacing = -1.0f;
15533 public static void SameLine(
float offsetFromStartX,
float spacing)
15544 byte* nativeIniFilename;
15545 int iniFilenameByteCount = 0;
15546 if (iniFilename !=
null)
15548 iniFilenameByteCount = Encoding.UTF8.GetByteCount(iniFilename);
15551 nativeIniFilename =
Util.
Allocate(iniFilenameByteCount + 1);
15555 byte* nativeIniFilenameStackBytes = stackalloc
byte[iniFilenameByteCount + 1];
15556 nativeIniFilename = nativeIniFilenameStackBytes;
15559 int nativeIniFilenameOffset =
Util.
GetUtf8(iniFilename, nativeIniFilename, iniFilenameByteCount);
15560 nativeIniFilename[nativeIniFilenameOffset] = 0;
15564 nativeIniFilename =
null;
15580 uint* outIniSize =
null;
15592 fixed (uint* nativeOutIniSize = &outIniSize)
15607 int labelByteCount = 0;
15610 labelByteCount = Encoding.UTF8.GetByteCount(label);
15617 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15618 nativeLabel = nativeLabelStackBytes;
15621 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15622 nativeLabel[nativeLabelOffset] = 0;
15626 nativeLabel =
null;
15650 int labelByteCount = 0;
15653 labelByteCount = Encoding.UTF8.GetByteCount(label);
15660 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15661 nativeLabel = nativeLabelStackBytes;
15664 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15665 nativeLabel[nativeLabelOffset] = 0;
15669 nativeLabel =
null;
15672 byte nativeSelected = selected ? (byte) 1 : (
byte) 0;
15694 int labelByteCount = 0;
15697 labelByteCount = Encoding.UTF8.GetByteCount(label);
15704 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15705 nativeLabel = nativeLabelStackBytes;
15708 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15709 nativeLabel[nativeLabelOffset] = 0;
15713 nativeLabel =
null;
15716 byte nativeSelected = selected ? (byte) 1 : (
byte) 0;
15738 int labelByteCount = 0;
15741 labelByteCount = Encoding.UTF8.GetByteCount(label);
15748 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15749 nativeLabel = nativeLabelStackBytes;
15752 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15753 nativeLabel[nativeLabelOffset] = 0;
15757 nativeLabel =
null;
15760 byte nativeSelected = selected ? (byte) 1 : (
byte) 0;
15779 int labelByteCount = 0;
15782 labelByteCount = Encoding.UTF8.GetByteCount(label);
15789 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15790 nativeLabel = nativeLabelStackBytes;
15793 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15794 nativeLabel[nativeLabelOffset] = 0;
15798 nativeLabel =
null;
15801 byte nativePSelectedVal = pSelected ? (byte) 1 : (
byte) 0;
15802 byte* nativePSelected = &nativePSelectedVal;
15811 pSelected = nativePSelectedVal != 0;
15825 int labelByteCount = 0;
15828 labelByteCount = Encoding.UTF8.GetByteCount(label);
15835 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15836 nativeLabel = nativeLabelStackBytes;
15839 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15840 nativeLabel[nativeLabelOffset] = 0;
15844 nativeLabel =
null;
15847 byte nativePSelectedVal = pSelected ? (byte) 1 : (
byte) 0;
15848 byte* nativePSelected = &nativePSelectedVal;
15856 pSelected = nativePSelectedVal != 0;
15871 int labelByteCount = 0;
15874 labelByteCount = Encoding.UTF8.GetByteCount(label);
15881 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15882 nativeLabel = nativeLabelStackBytes;
15885 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15886 nativeLabel[nativeLabelOffset] = 0;
15890 nativeLabel =
null;
15893 byte nativePSelectedVal = pSelected ? (byte) 1 : (
byte) 0;
15894 byte* nativePSelected = &nativePSelectedVal;
15901 pSelected = nativePSelectedVal != 0;
15920 int labelByteCount = 0;
15923 labelByteCount = Encoding.UTF8.GetByteCount(label);
15930 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
15931 nativeLabel = nativeLabelStackBytes;
15934 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
15935 nativeLabel[nativeLabelOffset] = 0;
15939 nativeLabel =
null;
15956 void* userData =
null;
15968 void* nativeUserData = userData.ToPointer();
15979 int textByteCount = 0;
15982 textByteCount = Encoding.UTF8.GetByteCount(text);
15989 byte* nativeTextStackBytes = stackalloc
byte[textByteCount + 1];
15990 nativeText = nativeTextStackBytes;
15993 int nativeTextOffset =
Util.
GetUtf8(text, nativeText, textByteCount);
15994 nativeText[nativeTextOffset] = 0;
16092 int typeByteCount = 0;
16095 typeByteCount = Encoding.UTF8.GetByteCount(type);
16102 byte* nativeTypeStackBytes = stackalloc
byte[typeByteCount + 1];
16103 nativeType = nativeTypeStackBytes;
16106 int nativeTypeOffset =
Util.
GetUtf8(type, nativeType, typeByteCount);
16107 nativeType[nativeTypeOffset] = 0;
16114 void* nativeData = data.ToPointer();
16136 int typeByteCount = 0;
16139 typeByteCount = Encoding.UTF8.GetByteCount(type);
16146 byte* nativeTypeStackBytes = stackalloc
byte[typeByteCount + 1];
16147 nativeType = nativeTypeStackBytes;
16150 int nativeTypeOffset =
Util.
GetUtf8(type, nativeType, typeByteCount);
16151 nativeType[nativeTypeOffset] = 0;
16158 void* nativeData = data.ToPointer();
16217 byte nativeWantCaptureKeyboard = wantCaptureKeyboard ? (byte) 1 : (
byte) 0;
16227 byte nativeWantCaptureMouse = wantCaptureMouse ? (byte) 1 : (
byte) 0;
16237 byte nativeIsOpen = isOpen ? (byte) 1 : (
byte) 0;
16249 byte nativeIsOpen = isOpen ? (byte) 1 : (
byte) 0;
16287 byte nativeCollapsed = collapsed ? (byte) 1 : (
byte) 0;
16299 byte nativeCollapsed = collapsed ? (byte) 1 : (
byte) 0;
16410 void* customCallbackData =
null;
16422 void* customCallbackData =
null;
16435 void* nativeCustomCallbackData = customCallbackData.ToPointer();
16454 float centerXRatio = 0.5f;
16474 float centerYRatio = 0.5f;
16493 float centerXRatio = 0.5f;
16511 float centerYRatio = 0.5f;
16558 byte* nativeTabOrDockedWindowLabel;
16559 int tabOrDockedWindowLabelByteCount = 0;
16560 if (tabOrDockedWindowLabel !=
null)
16562 tabOrDockedWindowLabelByteCount = Encoding.UTF8.GetByteCount(tabOrDockedWindowLabel);
16565 nativeTabOrDockedWindowLabel =
Util.
Allocate(tabOrDockedWindowLabelByteCount + 1);
16569 byte* nativeTabOrDockedWindowLabelStackBytes = stackalloc
byte[tabOrDockedWindowLabelByteCount + 1];
16570 nativeTabOrDockedWindowLabel = nativeTabOrDockedWindowLabelStackBytes;
16573 int nativeTabOrDockedWindowLabelOffset =
Util.
GetUtf8(tabOrDockedWindowLabel, nativeTabOrDockedWindowLabel, tabOrDockedWindowLabelByteCount);
16574 nativeTabOrDockedWindowLabel[nativeTabOrDockedWindowLabelOffset] = 0;
16578 nativeTabOrDockedWindowLabel =
null;
16584 Util.
Free(nativeTabOrDockedWindowLabel);
16595 int fmtByteCount = 0;
16598 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
16605 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
16606 nativeFmt = nativeFmtStackBytes;
16609 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
16610 nativeFmt[nativeFmtOffset] = 0;
16630 byte nativeCollapsed = collapsed ? (byte) 1 : (
byte) 0;
16642 byte nativeCollapsed = collapsed ? (byte) 1 : (
byte) 0;
16654 int nameByteCount = 0;
16657 nameByteCount = Encoding.UTF8.GetByteCount(name);
16664 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
16665 nativeName = nativeNameStackBytes;
16668 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
16669 nativeName[nativeNameOffset] = 0;
16676 byte nativeCollapsed = collapsed ? (byte) 1 : (
byte) 0;
16694 int nameByteCount = 0;
16697 nameByteCount = Encoding.UTF8.GetByteCount(name);
16704 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
16705 nativeName = nativeNameStackBytes;
16708 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
16709 nativeName[nativeNameOffset] = 0;
16716 byte nativeCollapsed = collapsed ? (byte) 1 : (
byte) 0;
16739 int nameByteCount = 0;
16742 nameByteCount = Encoding.UTF8.GetByteCount(name);
16749 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
16750 nativeName = nativeNameStackBytes;
16753 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
16754 nativeName[nativeNameOffset] = 0;
16805 int nameByteCount = 0;
16808 nameByteCount = Encoding.UTF8.GetByteCount(name);
16815 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
16816 nativeName = nativeNameStackBytes;
16819 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
16820 nativeName[nativeNameOffset] = 0;
16844 int nameByteCount = 0;
16847 nameByteCount = Encoding.UTF8.GetByteCount(name);
16854 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
16855 nativeName = nativeNameStackBytes;
16858 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
16859 nativeName[nativeNameOffset] = 0;
16901 int nameByteCount = 0;
16904 nameByteCount = Encoding.UTF8.GetByteCount(name);
16911 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
16912 nativeName = nativeNameStackBytes;
16915 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
16916 nativeName[nativeNameOffset] = 0;
16940 int nameByteCount = 0;
16943 nameByteCount = Encoding.UTF8.GetByteCount(name);
16950 byte* nativeNameStackBytes = stackalloc
byte[nameByteCount + 1];
16951 nativeName = nativeNameStackBytes;
16954 int nativeNameOffset =
Util.
GetUtf8(name, nativeName, nameByteCount);
16955 nativeName[nativeNameOffset] = 0;
16974 byte* pOpen =
null;
16984 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
16985 byte* nativePOpen = &nativePOpenVal;
16987 pOpen = nativePOpenVal != 0;
16995 byte* pOpen =
null;
17005 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
17006 byte* nativePOpen = &nativePOpenVal;
17008 pOpen = nativePOpenVal != 0;
17016 byte* pOpen =
null;
17026 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
17027 byte* nativePOpen = &nativePOpenVal;
17029 pOpen = nativePOpenVal != 0;
17039 int labelByteCount = 0;
17042 labelByteCount = Encoding.UTF8.GetByteCount(label);
17049 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17050 nativeLabel = nativeLabelStackBytes;
17053 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17054 nativeLabel[nativeLabelOffset] = 0;
17058 nativeLabel =
null;
17073 byte* pOpen =
null;
17083 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
17084 byte* nativePOpen = &nativePOpenVal;
17086 pOpen = nativePOpenVal != 0;
17094 byte* pOpen =
null;
17104 byte nativePOpenVal = pOpen ? (byte) 1 : (
byte) 0;
17105 byte* nativePOpen = &nativePOpenVal;
17107 pOpen = nativePOpenVal != 0;
17136 int labelByteCount = 0;
17139 labelByteCount = Encoding.UTF8.GetByteCount(label);
17146 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17147 nativeLabel = nativeLabelStackBytes;
17150 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17151 nativeLabel[nativeLabelOffset] = 0;
17155 nativeLabel =
null;
17184 int labelByteCount = 0;
17187 labelByteCount = Encoding.UTF8.GetByteCount(label);
17194 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17195 nativeLabel = nativeLabelStackBytes;
17198 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17199 nativeLabel[nativeLabelOffset] = 0;
17203 nativeLabel =
null;
17206 float vDegreesMin = -360.0f;
17207 float vDegreesMax = +360.0f;
17208 byte* nativeFormat;
17209 int formatByteCount = 0;
17210 formatByteCount = Encoding.UTF8.GetByteCount(
"%.0f deg");
17217 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17218 nativeFormat = nativeFormatStackBytes;
17221 int nativeFormatOffset =
Util.
GetUtf8(
"%.0f deg", nativeFormat, formatByteCount);
17222 nativeFormat[nativeFormatOffset] = 0;
17224 fixed (
float* nativeVRad = &vRad)
17248 public static bool SliderAngle(
string label, ref
float vRad,
float vDegreesMin)
17251 int labelByteCount = 0;
17254 labelByteCount = Encoding.UTF8.GetByteCount(label);
17261 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17262 nativeLabel = nativeLabelStackBytes;
17265 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17266 nativeLabel[nativeLabelOffset] = 0;
17270 nativeLabel =
null;
17273 float vDegreesMax = +360.0f;
17274 byte* nativeFormat;
17275 int formatByteCount = 0;
17276 formatByteCount = Encoding.UTF8.GetByteCount(
"%.0f deg");
17283 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17284 nativeFormat = nativeFormatStackBytes;
17287 int nativeFormatOffset =
Util.
GetUtf8(
"%.0f deg", nativeFormat, formatByteCount);
17288 nativeFormat[nativeFormatOffset] = 0;
17290 fixed (
float* nativeVRad = &vRad)
17315 public static bool SliderAngle(
string label, ref
float vRad,
float vDegreesMin,
float vDegreesMax)
17318 int labelByteCount = 0;
17321 labelByteCount = Encoding.UTF8.GetByteCount(label);
17328 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17329 nativeLabel = nativeLabelStackBytes;
17332 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17333 nativeLabel[nativeLabelOffset] = 0;
17337 nativeLabel =
null;
17340 byte* nativeFormat;
17341 int formatByteCount = 0;
17342 formatByteCount = Encoding.UTF8.GetByteCount(
"%.0f deg");
17349 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17350 nativeFormat = nativeFormatStackBytes;
17353 int nativeFormatOffset =
Util.
GetUtf8(
"%.0f deg", nativeFormat, formatByteCount);
17354 nativeFormat[nativeFormatOffset] = 0;
17356 fixed (
float* nativeVRad = &vRad)
17382 public static bool SliderAngle(
string label, ref
float vRad,
float vDegreesMin,
float vDegreesMax,
string format)
17385 int labelByteCount = 0;
17388 labelByteCount = Encoding.UTF8.GetByteCount(label);
17395 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17396 nativeLabel = nativeLabelStackBytes;
17399 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17400 nativeLabel[nativeLabelOffset] = 0;
17404 nativeLabel =
null;
17407 byte* nativeFormat;
17408 int formatByteCount = 0;
17409 if (format !=
null)
17411 formatByteCount = Encoding.UTF8.GetByteCount(format);
17418 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17419 nativeFormat = nativeFormatStackBytes;
17422 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
17423 nativeFormat[nativeFormatOffset] = 0;
17427 nativeFormat =
null;
17431 fixed (
float* nativeVRad = &vRad)
17461 int labelByteCount = 0;
17464 labelByteCount = Encoding.UTF8.GetByteCount(label);
17471 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17472 nativeLabel = nativeLabelStackBytes;
17475 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17476 nativeLabel[nativeLabelOffset] = 0;
17480 nativeLabel =
null;
17483 byte* nativeFormat;
17484 int formatByteCount = 0;
17485 if (format !=
null)
17487 formatByteCount = Encoding.UTF8.GetByteCount(format);
17494 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17495 nativeFormat = nativeFormatStackBytes;
17498 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
17499 nativeFormat[nativeFormatOffset] = 0;
17503 nativeFormat =
null;
17506 fixed (
float* nativeVRad = &vRad)
17531 public static bool SliderFloat(
string label, ref
float v,
float vMin,
float vMax)
17534 int labelByteCount = 0;
17537 labelByteCount = Encoding.UTF8.GetByteCount(label);
17544 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17545 nativeLabel = nativeLabelStackBytes;
17548 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17549 nativeLabel[nativeLabelOffset] = 0;
17553 nativeLabel =
null;
17556 byte* nativeFormat;
17557 int formatByteCount = 0;
17558 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
17565 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17566 nativeFormat = nativeFormatStackBytes;
17569 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
17570 nativeFormat[nativeFormatOffset] = 0;
17572 fixed (
float* nativeV = &v)
17598 public static bool SliderFloat(
string label, ref
float v,
float vMin,
float vMax,
string format)
17601 int labelByteCount = 0;
17604 labelByteCount = Encoding.UTF8.GetByteCount(label);
17611 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17612 nativeLabel = nativeLabelStackBytes;
17615 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17616 nativeLabel[nativeLabelOffset] = 0;
17620 nativeLabel =
null;
17623 byte* nativeFormat;
17624 int formatByteCount = 0;
17625 if (format !=
null)
17627 formatByteCount = Encoding.UTF8.GetByteCount(format);
17634 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17635 nativeFormat = nativeFormatStackBytes;
17638 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
17639 nativeFormat[nativeFormatOffset] = 0;
17643 nativeFormat =
null;
17647 fixed (
float* nativeV = &v)
17677 int labelByteCount = 0;
17680 labelByteCount = Encoding.UTF8.GetByteCount(label);
17687 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17688 nativeLabel = nativeLabelStackBytes;
17691 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17692 nativeLabel[nativeLabelOffset] = 0;
17696 nativeLabel =
null;
17699 byte* nativeFormat;
17700 int formatByteCount = 0;
17701 if (format !=
null)
17703 formatByteCount = Encoding.UTF8.GetByteCount(format);
17710 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17711 nativeFormat = nativeFormatStackBytes;
17714 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
17715 nativeFormat[nativeFormatOffset] = 0;
17719 nativeFormat =
null;
17722 fixed (
float* nativeV = &v)
17750 int labelByteCount = 0;
17753 labelByteCount = Encoding.UTF8.GetByteCount(label);
17760 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17761 nativeLabel = nativeLabelStackBytes;
17764 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17765 nativeLabel[nativeLabelOffset] = 0;
17769 nativeLabel =
null;
17772 byte* nativeFormat;
17773 int formatByteCount = 0;
17774 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
17781 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17782 nativeFormat = nativeFormatStackBytes;
17785 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
17786 nativeFormat[nativeFormatOffset] = 0;
17817 int labelByteCount = 0;
17820 labelByteCount = Encoding.UTF8.GetByteCount(label);
17827 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17828 nativeLabel = nativeLabelStackBytes;
17831 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17832 nativeLabel[nativeLabelOffset] = 0;
17836 nativeLabel =
null;
17839 byte* nativeFormat;
17840 int formatByteCount = 0;
17841 if (format !=
null)
17843 formatByteCount = Encoding.UTF8.GetByteCount(format);
17850 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17851 nativeFormat = nativeFormatStackBytes;
17854 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
17855 nativeFormat[nativeFormatOffset] = 0;
17859 nativeFormat =
null;
17893 int labelByteCount = 0;
17896 labelByteCount = Encoding.UTF8.GetByteCount(label);
17903 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17904 nativeLabel = nativeLabelStackBytes;
17907 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17908 nativeLabel[nativeLabelOffset] = 0;
17912 nativeLabel =
null;
17915 byte* nativeFormat;
17916 int formatByteCount = 0;
17917 if (format !=
null)
17919 formatByteCount = Encoding.UTF8.GetByteCount(format);
17926 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17927 nativeFormat = nativeFormatStackBytes;
17930 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
17931 nativeFormat[nativeFormatOffset] = 0;
17935 nativeFormat =
null;
17966 int labelByteCount = 0;
17969 labelByteCount = Encoding.UTF8.GetByteCount(label);
17976 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
17977 nativeLabel = nativeLabelStackBytes;
17980 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
17981 nativeLabel[nativeLabelOffset] = 0;
17985 nativeLabel =
null;
17988 byte* nativeFormat;
17989 int formatByteCount = 0;
17990 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
17997 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
17998 nativeFormat = nativeFormatStackBytes;
18001 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
18002 nativeFormat[nativeFormatOffset] = 0;
18033 int labelByteCount = 0;
18036 labelByteCount = Encoding.UTF8.GetByteCount(label);
18043 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18044 nativeLabel = nativeLabelStackBytes;
18047 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18048 nativeLabel[nativeLabelOffset] = 0;
18052 nativeLabel =
null;
18055 byte* nativeFormat;
18056 int formatByteCount = 0;
18057 if (format !=
null)
18059 formatByteCount = Encoding.UTF8.GetByteCount(format);
18066 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18067 nativeFormat = nativeFormatStackBytes;
18070 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18071 nativeFormat[nativeFormatOffset] = 0;
18075 nativeFormat =
null;
18109 int labelByteCount = 0;
18112 labelByteCount = Encoding.UTF8.GetByteCount(label);
18119 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18120 nativeLabel = nativeLabelStackBytes;
18123 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18124 nativeLabel[nativeLabelOffset] = 0;
18128 nativeLabel =
null;
18131 byte* nativeFormat;
18132 int formatByteCount = 0;
18133 if (format !=
null)
18135 formatByteCount = Encoding.UTF8.GetByteCount(format);
18142 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18143 nativeFormat = nativeFormatStackBytes;
18146 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18147 nativeFormat[nativeFormatOffset] = 0;
18151 nativeFormat =
null;
18182 int labelByteCount = 0;
18185 labelByteCount = Encoding.UTF8.GetByteCount(label);
18192 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18193 nativeLabel = nativeLabelStackBytes;
18196 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18197 nativeLabel[nativeLabelOffset] = 0;
18201 nativeLabel =
null;
18204 byte* nativeFormat;
18205 int formatByteCount = 0;
18206 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
18213 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18214 nativeFormat = nativeFormatStackBytes;
18217 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
18218 nativeFormat[nativeFormatOffset] = 0;
18249 int labelByteCount = 0;
18252 labelByteCount = Encoding.UTF8.GetByteCount(label);
18259 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18260 nativeLabel = nativeLabelStackBytes;
18263 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18264 nativeLabel[nativeLabelOffset] = 0;
18268 nativeLabel =
null;
18271 byte* nativeFormat;
18272 int formatByteCount = 0;
18273 if (format !=
null)
18275 formatByteCount = Encoding.UTF8.GetByteCount(format);
18282 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18283 nativeFormat = nativeFormatStackBytes;
18286 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18287 nativeFormat[nativeFormatOffset] = 0;
18291 nativeFormat =
null;
18325 int labelByteCount = 0;
18328 labelByteCount = Encoding.UTF8.GetByteCount(label);
18335 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18336 nativeLabel = nativeLabelStackBytes;
18339 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18340 nativeLabel[nativeLabelOffset] = 0;
18344 nativeLabel =
null;
18347 byte* nativeFormat;
18348 int formatByteCount = 0;
18349 if (format !=
null)
18351 formatByteCount = Encoding.UTF8.GetByteCount(format);
18358 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18359 nativeFormat = nativeFormatStackBytes;
18362 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18363 nativeFormat[nativeFormatOffset] = 0;
18367 nativeFormat =
null;
18395 public static bool SliderInt(
string label, ref
int v,
int vMin,
int vMax)
18398 int labelByteCount = 0;
18401 labelByteCount = Encoding.UTF8.GetByteCount(label);
18408 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18409 nativeLabel = nativeLabelStackBytes;
18412 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18413 nativeLabel[nativeLabelOffset] = 0;
18417 nativeLabel =
null;
18420 byte* nativeFormat;
18421 int formatByteCount = 0;
18422 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
18429 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18430 nativeFormat = nativeFormatStackBytes;
18433 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
18434 nativeFormat[nativeFormatOffset] = 0;
18436 fixed (
int* nativeV = &v)
18462 public static bool SliderInt(
string label, ref
int v,
int vMin,
int vMax,
string format)
18465 int labelByteCount = 0;
18468 labelByteCount = Encoding.UTF8.GetByteCount(label);
18475 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18476 nativeLabel = nativeLabelStackBytes;
18479 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18480 nativeLabel[nativeLabelOffset] = 0;
18484 nativeLabel =
null;
18487 byte* nativeFormat;
18488 int formatByteCount = 0;
18489 if (format !=
null)
18491 formatByteCount = Encoding.UTF8.GetByteCount(format);
18498 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18499 nativeFormat = nativeFormatStackBytes;
18502 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18503 nativeFormat[nativeFormatOffset] = 0;
18507 nativeFormat =
null;
18511 fixed (
int* nativeV = &v)
18541 int labelByteCount = 0;
18544 labelByteCount = Encoding.UTF8.GetByteCount(label);
18551 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18552 nativeLabel = nativeLabelStackBytes;
18555 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18556 nativeLabel[nativeLabelOffset] = 0;
18560 nativeLabel =
null;
18563 byte* nativeFormat;
18564 int formatByteCount = 0;
18565 if (format !=
null)
18567 formatByteCount = Encoding.UTF8.GetByteCount(format);
18574 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18575 nativeFormat = nativeFormatStackBytes;
18578 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18579 nativeFormat[nativeFormatOffset] = 0;
18583 nativeFormat =
null;
18586 fixed (
int* nativeV = &v)
18611 public static bool SliderInt2(
string label, ref
int v,
int vMin,
int vMax)
18614 int labelByteCount = 0;
18617 labelByteCount = Encoding.UTF8.GetByteCount(label);
18624 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18625 nativeLabel = nativeLabelStackBytes;
18628 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18629 nativeLabel[nativeLabelOffset] = 0;
18633 nativeLabel =
null;
18636 byte* nativeFormat;
18637 int formatByteCount = 0;
18638 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
18645 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18646 nativeFormat = nativeFormatStackBytes;
18649 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
18650 nativeFormat[nativeFormatOffset] = 0;
18652 fixed (
int* nativeV = &v)
18678 public static bool SliderInt2(
string label, ref
int v,
int vMin,
int vMax,
string format)
18681 int labelByteCount = 0;
18684 labelByteCount = Encoding.UTF8.GetByteCount(label);
18691 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18692 nativeLabel = nativeLabelStackBytes;
18695 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18696 nativeLabel[nativeLabelOffset] = 0;
18700 nativeLabel =
null;
18703 byte* nativeFormat;
18704 int formatByteCount = 0;
18705 if (format !=
null)
18707 formatByteCount = Encoding.UTF8.GetByteCount(format);
18714 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18715 nativeFormat = nativeFormatStackBytes;
18718 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18719 nativeFormat[nativeFormatOffset] = 0;
18723 nativeFormat =
null;
18727 fixed (
int* nativeV = &v)
18757 int labelByteCount = 0;
18760 labelByteCount = Encoding.UTF8.GetByteCount(label);
18767 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18768 nativeLabel = nativeLabelStackBytes;
18771 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18772 nativeLabel[nativeLabelOffset] = 0;
18776 nativeLabel =
null;
18779 byte* nativeFormat;
18780 int formatByteCount = 0;
18781 if (format !=
null)
18783 formatByteCount = Encoding.UTF8.GetByteCount(format);
18790 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18791 nativeFormat = nativeFormatStackBytes;
18794 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18795 nativeFormat[nativeFormatOffset] = 0;
18799 nativeFormat =
null;
18802 fixed (
int* nativeV = &v)
18827 public static bool SliderInt3(
string label, ref
int v,
int vMin,
int vMax)
18830 int labelByteCount = 0;
18833 labelByteCount = Encoding.UTF8.GetByteCount(label);
18840 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18841 nativeLabel = nativeLabelStackBytes;
18844 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18845 nativeLabel[nativeLabelOffset] = 0;
18849 nativeLabel =
null;
18852 byte* nativeFormat;
18853 int formatByteCount = 0;
18854 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
18861 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18862 nativeFormat = nativeFormatStackBytes;
18865 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
18866 nativeFormat[nativeFormatOffset] = 0;
18868 fixed (
int* nativeV = &v)
18894 public static bool SliderInt3(
string label, ref
int v,
int vMin,
int vMax,
string format)
18897 int labelByteCount = 0;
18900 labelByteCount = Encoding.UTF8.GetByteCount(label);
18907 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18908 nativeLabel = nativeLabelStackBytes;
18911 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18912 nativeLabel[nativeLabelOffset] = 0;
18916 nativeLabel =
null;
18919 byte* nativeFormat;
18920 int formatByteCount = 0;
18921 if (format !=
null)
18923 formatByteCount = Encoding.UTF8.GetByteCount(format);
18930 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
18931 nativeFormat = nativeFormatStackBytes;
18934 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
18935 nativeFormat[nativeFormatOffset] = 0;
18939 nativeFormat =
null;
18943 fixed (
int* nativeV = &v)
18973 int labelByteCount = 0;
18976 labelByteCount = Encoding.UTF8.GetByteCount(label);
18983 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
18984 nativeLabel = nativeLabelStackBytes;
18987 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
18988 nativeLabel[nativeLabelOffset] = 0;
18992 nativeLabel =
null;
18995 byte* nativeFormat;
18996 int formatByteCount = 0;
18997 if (format !=
null)
18999 formatByteCount = Encoding.UTF8.GetByteCount(format);
19006 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19007 nativeFormat = nativeFormatStackBytes;
19010 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
19011 nativeFormat[nativeFormatOffset] = 0;
19015 nativeFormat =
null;
19018 fixed (
int* nativeV = &v)
19043 public static bool SliderInt4(
string label, ref
int v,
int vMin,
int vMax)
19046 int labelByteCount = 0;
19049 labelByteCount = Encoding.UTF8.GetByteCount(label);
19056 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19057 nativeLabel = nativeLabelStackBytes;
19060 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19061 nativeLabel[nativeLabelOffset] = 0;
19065 nativeLabel =
null;
19068 byte* nativeFormat;
19069 int formatByteCount = 0;
19070 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
19077 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19078 nativeFormat = nativeFormatStackBytes;
19081 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
19082 nativeFormat[nativeFormatOffset] = 0;
19084 fixed (
int* nativeV = &v)
19110 public static bool SliderInt4(
string label, ref
int v,
int vMin,
int vMax,
string format)
19113 int labelByteCount = 0;
19116 labelByteCount = Encoding.UTF8.GetByteCount(label);
19123 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19124 nativeLabel = nativeLabelStackBytes;
19127 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19128 nativeLabel[nativeLabelOffset] = 0;
19132 nativeLabel =
null;
19135 byte* nativeFormat;
19136 int formatByteCount = 0;
19137 if (format !=
null)
19139 formatByteCount = Encoding.UTF8.GetByteCount(format);
19146 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19147 nativeFormat = nativeFormatStackBytes;
19150 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
19151 nativeFormat[nativeFormatOffset] = 0;
19155 nativeFormat =
null;
19159 fixed (
int* nativeV = &v)
19189 int labelByteCount = 0;
19192 labelByteCount = Encoding.UTF8.GetByteCount(label);
19199 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19200 nativeLabel = nativeLabelStackBytes;
19203 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19204 nativeLabel[nativeLabelOffset] = 0;
19208 nativeLabel =
null;
19211 byte* nativeFormat;
19212 int formatByteCount = 0;
19213 if (format !=
null)
19215 formatByteCount = Encoding.UTF8.GetByteCount(format);
19222 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19223 nativeFormat = nativeFormatStackBytes;
19226 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
19227 nativeFormat[nativeFormatOffset] = 0;
19231 nativeFormat =
null;
19234 fixed (
int* nativeV = &v)
19263 int labelByteCount = 0;
19266 labelByteCount = Encoding.UTF8.GetByteCount(label);
19273 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19274 nativeLabel = nativeLabelStackBytes;
19277 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19278 nativeLabel[nativeLabelOffset] = 0;
19282 nativeLabel =
null;
19285 void* nativePData = pData.ToPointer();
19286 void* nativePMin = pMin.ToPointer();
19287 void* nativePMax = pMax.ToPointer();
19288 byte* nativeFormat =
null;
19290 byte ret =
ImGuiNative.
igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
19312 int labelByteCount = 0;
19315 labelByteCount = Encoding.UTF8.GetByteCount(label);
19322 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19323 nativeLabel = nativeLabelStackBytes;
19326 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19327 nativeLabel[nativeLabelOffset] = 0;
19331 nativeLabel =
null;
19334 void* nativePData = pData.ToPointer();
19335 void* nativePMin = pMin.ToPointer();
19336 void* nativePMax = pMax.ToPointer();
19337 byte* nativeFormat;
19338 int formatByteCount = 0;
19339 if (format !=
null)
19341 formatByteCount = Encoding.UTF8.GetByteCount(format);
19348 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19349 nativeFormat = nativeFormatStackBytes;
19352 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
19353 nativeFormat[nativeFormatOffset] = 0;
19357 nativeFormat =
null;
19361 byte ret =
ImGuiNative.
igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
19389 int labelByteCount = 0;
19392 labelByteCount = Encoding.UTF8.GetByteCount(label);
19399 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19400 nativeLabel = nativeLabelStackBytes;
19403 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19404 nativeLabel[nativeLabelOffset] = 0;
19408 nativeLabel =
null;
19411 void* nativePData = pData.ToPointer();
19412 void* nativePMin = pMin.ToPointer();
19413 void* nativePMax = pMax.ToPointer();
19414 byte* nativeFormat;
19415 int formatByteCount = 0;
19416 if (format !=
null)
19418 formatByteCount = Encoding.UTF8.GetByteCount(format);
19425 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19426 nativeFormat = nativeFormatStackBytes;
19429 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
19430 nativeFormat[nativeFormatOffset] = 0;
19434 nativeFormat =
null;
19437 byte ret =
ImGuiNative.
igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
19464 int labelByteCount = 0;
19467 labelByteCount = Encoding.UTF8.GetByteCount(label);
19474 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19475 nativeLabel = nativeLabelStackBytes;
19478 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19479 nativeLabel[nativeLabelOffset] = 0;
19483 nativeLabel =
null;
19486 void* nativePData = pData.ToPointer();
19487 void* nativePMin = pMin.ToPointer();
19488 void* nativePMax = pMax.ToPointer();
19489 byte* nativeFormat =
null;
19491 byte ret =
ImGuiNative.
igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flags);
19514 int labelByteCount = 0;
19517 labelByteCount = Encoding.UTF8.GetByteCount(label);
19524 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19525 nativeLabel = nativeLabelStackBytes;
19528 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19529 nativeLabel[nativeLabelOffset] = 0;
19533 nativeLabel =
null;
19536 void* nativePData = pData.ToPointer();
19537 void* nativePMin = pMin.ToPointer();
19538 void* nativePMax = pMax.ToPointer();
19539 byte* nativeFormat;
19540 int formatByteCount = 0;
19541 if (format !=
null)
19543 formatByteCount = Encoding.UTF8.GetByteCount(format);
19550 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19551 nativeFormat = nativeFormatStackBytes;
19554 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
19555 nativeFormat[nativeFormatOffset] = 0;
19559 nativeFormat =
null;
19563 byte ret =
ImGuiNative.
igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flags);
19592 int labelByteCount = 0;
19595 labelByteCount = Encoding.UTF8.GetByteCount(label);
19602 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19603 nativeLabel = nativeLabelStackBytes;
19606 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19607 nativeLabel[nativeLabelOffset] = 0;
19611 nativeLabel =
null;
19614 void* nativePData = pData.ToPointer();
19615 void* nativePMin = pMin.ToPointer();
19616 void* nativePMax = pMax.ToPointer();
19617 byte* nativeFormat;
19618 int formatByteCount = 0;
19619 if (format !=
null)
19621 formatByteCount = Encoding.UTF8.GetByteCount(format);
19628 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
19629 nativeFormat = nativeFormatStackBytes;
19632 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
19633 nativeFormat[nativeFormatOffset] = 0;
19637 nativeFormat =
null;
19640 byte ret =
ImGuiNative.
igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flags);
19662 int labelByteCount = 0;
19665 labelByteCount = Encoding.UTF8.GetByteCount(label);
19672 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19673 nativeLabel = nativeLabelStackBytes;
19676 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19677 nativeLabel[nativeLabelOffset] = 0;
19681 nativeLabel =
null;
19766 int labelByteCount = 0;
19769 labelByteCount = Encoding.UTF8.GetByteCount(label);
19776 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19777 nativeLabel = nativeLabelStackBytes;
19780 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19781 nativeLabel[nativeLabelOffset] = 0;
19785 nativeLabel =
null;
19807 int labelByteCount = 0;
19810 labelByteCount = Encoding.UTF8.GetByteCount(label);
19817 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19818 nativeLabel = nativeLabelStackBytes;
19821 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19822 nativeLabel[nativeLabelOffset] = 0;
19826 nativeLabel =
null;
19929 int labelByteCount = 0;
19932 labelByteCount = Encoding.UTF8.GetByteCount(label);
19939 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
19940 nativeLabel = nativeLabelStackBytes;
19943 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
19944 nativeLabel[nativeLabelOffset] = 0;
19948 nativeLabel =
null;
19982 float minRowHeight = 0.0f;
19992 float minRowHeight = 0.0f;
20035 byte nativeV = v ? (byte) 1 : (
byte) 0;
20057 int labelByteCount = 0;
20060 labelByteCount = Encoding.UTF8.GetByteCount(label);
20067 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
20068 nativeLabel = nativeLabelStackBytes;
20071 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
20072 nativeLabel[nativeLabelOffset] = 0;
20076 nativeLabel =
null;
20080 float initWidthOrWeight = 0.0f;
20097 int labelByteCount = 0;
20100 labelByteCount = Encoding.UTF8.GetByteCount(label);
20107 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
20108 nativeLabel = nativeLabelStackBytes;
20111 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
20112 nativeLabel[nativeLabelOffset] = 0;
20116 nativeLabel =
null;
20119 float initWidthOrWeight = 0.0f;
20137 int labelByteCount = 0;
20140 labelByteCount = Encoding.UTF8.GetByteCount(label);
20147 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
20148 nativeLabel = nativeLabelStackBytes;
20151 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
20152 nativeLabel[nativeLabelOffset] = 0;
20156 nativeLabel =
null;
20177 int labelByteCount = 0;
20180 labelByteCount = Encoding.UTF8.GetByteCount(label);
20187 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
20188 nativeLabel = nativeLabelStackBytes;
20191 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
20192 nativeLabel[nativeLabelOffset] = 0;
20196 nativeLabel =
null;
20223 int fmtByteCount = 0;
20226 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20233 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20234 nativeFmt = nativeFmtStackBytes;
20237 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20238 nativeFmt[nativeFmtOffset] = 0;
20260 int fmtByteCount = 0;
20263 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20270 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20271 nativeFmt = nativeFmtStackBytes;
20274 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20275 nativeFmt[nativeFmtOffset] = 0;
20296 int fmtByteCount = 0;
20299 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20306 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20307 nativeFmt = nativeFmtStackBytes;
20310 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20311 nativeFmt[nativeFmtOffset] = 0;
20332 int textByteCount = 0;
20335 textByteCount = Encoding.UTF8.GetByteCount(text);
20342 byte* nativeTextStackBytes = stackalloc
byte[textByteCount + 1];
20343 nativeText = nativeTextStackBytes;
20346 int nativeTextOffset =
Util.
GetUtf8(text, nativeText, textByteCount);
20347 nativeText[nativeTextOffset] = 0;
20354 byte* nativeTextEnd =
null;
20369 int fmtByteCount = 0;
20372 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20379 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20380 nativeFmt = nativeFmtStackBytes;
20383 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20384 nativeFmt[nativeFmtOffset] = 0;
20406 int labelByteCount = 0;
20409 labelByteCount = Encoding.UTF8.GetByteCount(label);
20416 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
20417 nativeLabel = nativeLabelStackBytes;
20420 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
20421 nativeLabel[nativeLabelOffset] = 0;
20425 nativeLabel =
null;
20446 int strIdByteCount = 0;
20449 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20456 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
20457 nativeStrId = nativeStrIdStackBytes;
20460 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
20461 nativeStrId[nativeStrIdOffset] = 0;
20465 nativeStrId =
null;
20469 int fmtByteCount = 0;
20472 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20479 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20480 nativeFmt = nativeFmtStackBytes;
20483 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20484 nativeFmt[nativeFmtOffset] = 0;
20513 void* nativePtrId = ptrId.ToPointer();
20515 int fmtByteCount = 0;
20518 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20525 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20526 nativeFmt = nativeFmtStackBytes;
20529 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20530 nativeFmt[nativeFmtOffset] = 0;
20554 int labelByteCount = 0;
20557 labelByteCount = Encoding.UTF8.GetByteCount(label);
20564 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
20565 nativeLabel = nativeLabelStackBytes;
20568 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
20569 nativeLabel[nativeLabelOffset] = 0;
20573 nativeLabel =
null;
20595 int labelByteCount = 0;
20598 labelByteCount = Encoding.UTF8.GetByteCount(label);
20605 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
20606 nativeLabel = nativeLabelStackBytes;
20609 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
20610 nativeLabel[nativeLabelOffset] = 0;
20614 nativeLabel =
null;
20636 int strIdByteCount = 0;
20639 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20646 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
20647 nativeStrId = nativeStrIdStackBytes;
20650 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
20651 nativeStrId[nativeStrIdOffset] = 0;
20655 nativeStrId =
null;
20659 int fmtByteCount = 0;
20662 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20669 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20670 nativeFmt = nativeFmtStackBytes;
20673 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20674 nativeFmt[nativeFmtOffset] = 0;
20704 void* nativePtrId = ptrId.ToPointer();
20706 int fmtByteCount = 0;
20709 fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20716 byte* nativeFmtStackBytes = stackalloc
byte[fmtByteCount + 1];
20717 nativeFmt = nativeFmtStackBytes;
20720 int nativeFmtOffset =
Util.
GetUtf8(fmt, nativeFmt, fmtByteCount);
20721 nativeFmt[nativeFmtOffset] = 0;
20752 int strIdByteCount = 0;
20755 strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20762 byte* nativeStrIdStackBytes = stackalloc
byte[strIdByteCount + 1];
20763 nativeStrId = nativeStrIdStackBytes;
20766 int nativeStrIdOffset =
Util.
GetUtf8(strId, nativeStrId, strIdByteCount);
20767 nativeStrId[nativeStrIdOffset] = 0;
20771 nativeStrId =
null;
20787 void* nativePtrId = ptrId.ToPointer();
20796 float indentW = 0.0f;
20822 public static void Value(
string prefix,
bool b)
20824 byte* nativePrefix;
20825 int prefixByteCount = 0;
20826 if (prefix !=
null)
20828 prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20835 byte* nativePrefixStackBytes = stackalloc
byte[prefixByteCount + 1];
20836 nativePrefix = nativePrefixStackBytes;
20839 int nativePrefixOffset =
Util.
GetUtf8(prefix, nativePrefix, prefixByteCount);
20840 nativePrefix[nativePrefixOffset] = 0;
20844 nativePrefix =
null;
20847 byte nativeB = b ? (byte) 1 : (
byte) 0;
20860 public static void Value(
string prefix,
int v)
20862 byte* nativePrefix;
20863 int prefixByteCount = 0;
20864 if (prefix !=
null)
20866 prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20873 byte* nativePrefixStackBytes = stackalloc
byte[prefixByteCount + 1];
20874 nativePrefix = nativePrefixStackBytes;
20877 int nativePrefixOffset =
Util.
GetUtf8(prefix, nativePrefix, prefixByteCount);
20878 nativePrefix[nativePrefixOffset] = 0;
20882 nativePrefix =
null;
20897 public static void Value(
string prefix, uint v)
20899 byte* nativePrefix;
20900 int prefixByteCount = 0;
20901 if (prefix !=
null)
20903 prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20910 byte* nativePrefixStackBytes = stackalloc
byte[prefixByteCount + 1];
20911 nativePrefix = nativePrefixStackBytes;
20914 int nativePrefixOffset =
Util.
GetUtf8(prefix, nativePrefix, prefixByteCount);
20915 nativePrefix[nativePrefixOffset] = 0;
20919 nativePrefix =
null;
20934 public static void Value(
string prefix,
float v)
20936 byte* nativePrefix;
20937 int prefixByteCount = 0;
20938 if (prefix !=
null)
20940 prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20947 byte* nativePrefixStackBytes = stackalloc
byte[prefixByteCount + 1];
20948 nativePrefix = nativePrefixStackBytes;
20951 int nativePrefixOffset =
Util.
GetUtf8(prefix, nativePrefix, prefixByteCount);
20952 nativePrefix[nativePrefixOffset] = 0;
20956 nativePrefix =
null;
20959 byte* nativeFloatFormat =
null;
20973 public static void Value(
string prefix,
float v,
string floatFormat)
20975 byte* nativePrefix;
20976 int prefixByteCount = 0;
20977 if (prefix !=
null)
20979 prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20986 byte* nativePrefixStackBytes = stackalloc
byte[prefixByteCount + 1];
20987 nativePrefix = nativePrefixStackBytes;
20990 int nativePrefixOffset =
Util.
GetUtf8(prefix, nativePrefix, prefixByteCount);
20991 nativePrefix[nativePrefixOffset] = 0;
20995 nativePrefix =
null;
20998 byte* nativeFloatFormat;
20999 int floatFormatByteCount = 0;
21000 if (floatFormat !=
null)
21002 floatFormatByteCount = Encoding.UTF8.GetByteCount(floatFormat);
21005 nativeFloatFormat =
Util.
Allocate(floatFormatByteCount + 1);
21009 byte* nativeFloatFormatStackBytes = stackalloc
byte[floatFormatByteCount + 1];
21010 nativeFloatFormat = nativeFloatFormatStackBytes;
21013 int nativeFloatFormatOffset =
Util.
GetUtf8(floatFormat, nativeFloatFormat, floatFormatByteCount);
21014 nativeFloatFormat[nativeFloatFormatOffset] = 0;
21018 nativeFloatFormat =
null;
21045 int labelByteCount = 0;
21048 labelByteCount = Encoding.UTF8.GetByteCount(label);
21055 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21056 nativeLabel = nativeLabelStackBytes;
21059 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21060 nativeLabel[nativeLabelOffset] = 0;
21064 nativeLabel =
null;
21067 byte* nativeFormat;
21068 int formatByteCount = 0;
21069 formatByteCount = Encoding.UTF8.GetByteCount(
"%.3f");
21076 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21077 nativeFormat = nativeFormatStackBytes;
21080 int nativeFormatOffset =
Util.
GetUtf8(
"%.3f", nativeFormat, formatByteCount);
21081 nativeFormat[nativeFormatOffset] = 0;
21083 fixed (
float* nativeV = &v)
21113 int labelByteCount = 0;
21116 labelByteCount = Encoding.UTF8.GetByteCount(label);
21123 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21124 nativeLabel = nativeLabelStackBytes;
21127 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21128 nativeLabel[nativeLabelOffset] = 0;
21132 nativeLabel =
null;
21135 byte* nativeFormat;
21136 int formatByteCount = 0;
21137 if (format !=
null)
21139 formatByteCount = Encoding.UTF8.GetByteCount(format);
21146 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21147 nativeFormat = nativeFormatStackBytes;
21150 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
21151 nativeFormat[nativeFormatOffset] = 0;
21155 nativeFormat =
null;
21159 fixed (
float* nativeV = &v)
21190 int labelByteCount = 0;
21193 labelByteCount = Encoding.UTF8.GetByteCount(label);
21200 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21201 nativeLabel = nativeLabelStackBytes;
21204 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21205 nativeLabel[nativeLabelOffset] = 0;
21209 nativeLabel =
null;
21212 byte* nativeFormat;
21213 int formatByteCount = 0;
21214 if (format !=
null)
21216 formatByteCount = Encoding.UTF8.GetByteCount(format);
21223 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21224 nativeFormat = nativeFormatStackBytes;
21227 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
21228 nativeFormat[nativeFormatOffset] = 0;
21232 nativeFormat =
null;
21235 fixed (
float* nativeV = &v)
21264 int labelByteCount = 0;
21267 labelByteCount = Encoding.UTF8.GetByteCount(label);
21274 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21275 nativeLabel = nativeLabelStackBytes;
21278 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21279 nativeLabel[nativeLabelOffset] = 0;
21283 nativeLabel =
null;
21286 byte* nativeFormat;
21287 int formatByteCount = 0;
21288 formatByteCount = Encoding.UTF8.GetByteCount(
"%d");
21295 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21296 nativeFormat = nativeFormatStackBytes;
21299 int nativeFormatOffset =
Util.
GetUtf8(
"%d", nativeFormat, formatByteCount);
21300 nativeFormat[nativeFormatOffset] = 0;
21302 fixed (
int* nativeV = &v)
21332 int labelByteCount = 0;
21335 labelByteCount = Encoding.UTF8.GetByteCount(label);
21342 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21343 nativeLabel = nativeLabelStackBytes;
21346 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21347 nativeLabel[nativeLabelOffset] = 0;
21351 nativeLabel =
null;
21354 byte* nativeFormat;
21355 int formatByteCount = 0;
21356 if (format !=
null)
21358 formatByteCount = Encoding.UTF8.GetByteCount(format);
21365 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21366 nativeFormat = nativeFormatStackBytes;
21369 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
21370 nativeFormat[nativeFormatOffset] = 0;
21374 nativeFormat =
null;
21378 fixed (
int* nativeV = &v)
21409 int labelByteCount = 0;
21412 labelByteCount = Encoding.UTF8.GetByteCount(label);
21419 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21420 nativeLabel = nativeLabelStackBytes;
21423 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21424 nativeLabel[nativeLabelOffset] = 0;
21428 nativeLabel =
null;
21431 byte* nativeFormat;
21432 int formatByteCount = 0;
21433 if (format !=
null)
21435 formatByteCount = Encoding.UTF8.GetByteCount(format);
21442 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21443 nativeFormat = nativeFormatStackBytes;
21446 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
21447 nativeFormat[nativeFormatOffset] = 0;
21451 nativeFormat =
null;
21454 fixed (
int* nativeV = &v)
21484 int labelByteCount = 0;
21487 labelByteCount = Encoding.UTF8.GetByteCount(label);
21494 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21495 nativeLabel = nativeLabelStackBytes;
21498 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21499 nativeLabel[nativeLabelOffset] = 0;
21503 nativeLabel =
null;
21506 void* nativePData = pData.ToPointer();
21507 void* nativePMin = pMin.ToPointer();
21508 void* nativePMax = pMax.ToPointer();
21509 byte* nativeFormat =
null;
21511 byte ret =
ImGuiNative.
igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
21534 int labelByteCount = 0;
21537 labelByteCount = Encoding.UTF8.GetByteCount(label);
21544 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21545 nativeLabel = nativeLabelStackBytes;
21548 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21549 nativeLabel[nativeLabelOffset] = 0;
21553 nativeLabel =
null;
21556 void* nativePData = pData.ToPointer();
21557 void* nativePMin = pMin.ToPointer();
21558 void* nativePMax = pMax.ToPointer();
21559 byte* nativeFormat;
21560 int formatByteCount = 0;
21561 if (format !=
null)
21563 formatByteCount = Encoding.UTF8.GetByteCount(format);
21570 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21571 nativeFormat = nativeFormatStackBytes;
21574 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
21575 nativeFormat[nativeFormatOffset] = 0;
21579 nativeFormat =
null;
21583 byte ret =
ImGuiNative.
igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
21612 int labelByteCount = 0;
21615 labelByteCount = Encoding.UTF8.GetByteCount(label);
21622 byte* nativeLabelStackBytes = stackalloc
byte[labelByteCount + 1];
21623 nativeLabel = nativeLabelStackBytes;
21626 int nativeLabelOffset =
Util.
GetUtf8(label, nativeLabel, labelByteCount);
21627 nativeLabel[nativeLabelOffset] = 0;
21631 nativeLabel =
null;
21634 void* nativePData = pData.ToPointer();
21635 void* nativePMin = pMin.ToPointer();
21636 void* nativePMax = pMax.ToPointer();
21637 byte* nativeFormat;
21638 int formatByteCount = 0;
21639 if (format !=
null)
21641 formatByteCount = Encoding.UTF8.GetByteCount(format);
21648 byte* nativeFormatStackBytes = stackalloc
byte[formatByteCount + 1];
21649 nativeFormat = nativeFormatStackBytes;
21652 int nativeFormatOffset =
Util.
GetUtf8(format, nativeFormat, formatByteCount);
21653 nativeFormat[nativeFormatOffset] = 0;
21657 nativeFormat =
null;
21660 byte ret =
ImGuiNative.
igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
21685 =>
InputText(label, buf, bufSize, 0,
null, IntPtr.Zero);
21700 =>
InputText(label, buf, bufSize, flags,
null, IntPtr.Zero);
21716 ImGuiInputTextCallback callback)
21717 =>
InputText(label, buf, bufSize, flags, callback, IntPtr.Zero);
21734 ImGuiInputTextCallback callback,
21737 int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
21738 byte* utf8LabelBytes;
21741 utf8LabelBytes =
Util.
Allocate(utf8LabelByteCount + 1);
21745 byte* stackPtr = stackalloc
byte[utf8LabelByteCount + 1];
21746 utf8LabelBytes = stackPtr;
21749 Util.
GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
21752 fixed (
byte* bufPtr = buf)
21754 ret =
ImGuiNative.
igInputText(utf8LabelBytes, bufPtr, bufSize, flags, callback, userData.ToPointer()) != 0;
21775 uint maxLength) =>
InputText(label, ref input, maxLength, 0,
null, IntPtr.Zero);
21805 ImGuiInputTextCallback callback) =>
InputText(label, ref input, maxLength, flags, callback, IntPtr.Zero);
21822 ImGuiInputTextCallback callback,
21826 IntPtr labelPtr = Marshal.StringToHGlobalAnsi(label);
21827 IntPtr inputPtr = Marshal.StringToHGlobalAnsi(input);
21830 byte* utf8LabelBytes = (
byte*) labelPtr.ToPointer();
21831 byte* utf8InputBytes = (
byte*) inputPtr.ToPointer();
21834 int inputBufSize = Math.Max((
int) maxLength + 1, Encoding.UTF8.GetByteCount(input) + 1);
21835 byte* modifiedUtf8InputBytes = stackalloc
byte[inputBufSize];
21836 byte* originalUtf8InputBytes = stackalloc
byte[inputBufSize];
21839 Unsafe.
CopyBlock(modifiedUtf8InputBytes, utf8InputBytes, (uint) inputBufSize);
21844 modifiedUtf8InputBytes,
21845 (uint) inputBufSize,
21848 userData.ToPointer());
21853 input = Encoding.UTF8.GetString(modifiedUtf8InputBytes, inputBufSize);
21857 Marshal.FreeHGlobal(labelPtr);
21858 Marshal.FreeHGlobal(inputPtr);
21860 return result != 0;
21910 ImGuiInputTextCallback callback) =>
InputTextMultiline(label, ref input, maxLength, size, flags, callback, IntPtr.Zero);
21929 ImGuiInputTextCallback callback,
21933 IntPtr labelPtr = Marshal.StringToHGlobalAnsi(label);
21934 IntPtr inputPtr = Marshal.StringToHGlobalAnsi(input);
21937 byte* utf8LabelBytes = (
byte*) labelPtr.ToPointer();
21938 byte* utf8InputBytes = (
byte*) inputPtr.ToPointer();
21941 int inputBufSize = Math.Max((
int) maxLength + 1, Encoding.UTF8.GetByteCount(input) + 1);
21942 byte* modifiedUtf8InputBytes = stackalloc
byte[inputBufSize];
21943 byte* originalUtf8InputBytes = stackalloc
byte[inputBufSize];
21946 Unsafe.
CopyBlock(modifiedUtf8InputBytes, utf8InputBytes, (uint) inputBufSize);
21951 modifiedUtf8InputBytes,
21952 (uint) inputBufSize,
21956 userData.ToPointer());
21961 input = Encoding.UTF8.GetString(modifiedUtf8InputBytes, inputBufSize);
21965 Marshal.FreeHGlobal(labelPtr);
21966 Marshal.FreeHGlobal(inputPtr);
21968 return result != 0;
21980 if ((array1 ==
null) && (array2 ==
null))
21985 if (array1 ==
null || array2 ==
null || array1.Length != array2.Length)
21990 for (
int i = 0; i < array1.Length; i++)
21992 if (array1[i] != array2[i])
22014 uint maxLength) =>
InputTextWithHint(label, hint, ref input, maxLength, 0,
null, IntPtr.Zero);
22048 ImGuiInputTextCallback callback) =>
InputTextWithHint(label, hint, ref input, maxLength, flags, callback, IntPtr.Zero);
22067 ImGuiInputTextCallback callback,
22072 byte* utf8InputBytes =
GetUtf8Bytes(input, maxLength);
22081 userData.ToPointer());
22084 if (hasInputChanged)
22093 return result != 0;
22103 int byteCount = Encoding.UTF8.GetByteCount(text);
22104 byte* utf8Bytes = (
byte*) Marshal.AllocHGlobal(byteCount + 1);
22106 utf8Bytes[byteCount] = 0;
22119 int byteCount = Encoding.UTF8.GetByteCount(text);
22120 int inputBufSize = Math.Max((
int) maxLength + 1, byteCount + 1);
22121 byte[] utf8BytesArray =
new byte[inputBufSize];
22123 fixed (
byte* utf8Bytes = utf8BytesArray)
22128 byte* result = (
byte*) Marshal.AllocHGlobal(inputBufSize);
22129 Buffer.MemoryCopy(utf8Bytes, result, inputBufSize, inputBufSize);
22144 int byteCount = Encoding.UTF8.GetByteCount(text);
22175 if (utf8Bytes ==
null)
22181 while (*(utf8Bytes + length) != 0)
22223 =>
CalcTextSizeImpl(text, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
22243 =>
CalcTextSizeImpl(text, start, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
22263 =>
CalcTextSizeImpl(text, hideTextAfterDoubleHash: hideTextAfterDoubleHash, wrapWidth: wrapWidth);
22297 =>
CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
22311 int? length =
null,
22312 bool hideTextAfterDoubleHash =
false,
22313 float wrapWidth = -1.0f)
22316 byte* nativeTextStart =
null;
22317 byte* nativeTextEnd =
null;
22318 int textByteCount = 0;
22321 int textToCopyLen = length.HasValue ? length.Value : text.
Length;
22329 byte* nativeTextStackBytes = stackalloc
byte[textByteCount + 1];
22330 nativeTextStart = nativeTextStackBytes;
22333 int nativeTextOffset =
Util.
GetUtf8(text, start, textToCopyLen, nativeTextStart, textByteCount);
22334 nativeTextStart[nativeTextOffset] = 0;
22335 nativeTextEnd = nativeTextStart + nativeTextOffset;
22358 =>
InputText(label, buf, bufSize, 0,
null, IntPtr.Zero);
22373 =>
InputText(label, buf, bufSize, flags,
null, IntPtr.Zero);
22389 ImGuiInputTextCallback callback)
22390 =>
InputText(label, buf, bufSize, flags, callback, IntPtr.Zero);
22407 ImGuiInputTextCallback callback,
22410 int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
22411 byte* utf8LabelBytes;
22414 utf8LabelBytes =
Util.
Allocate(utf8LabelByteCount + 1);
22418 byte* stackPtr = stackalloc
byte[utf8LabelByteCount + 1];
22419 utf8LabelBytes = stackPtr;
22422 Util.
GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
22424 bool ret =
ImGuiNative.
igInputText(utf8LabelBytes, (
byte*) buf.ToPointer(), bufSize, flags, callback, userData.ToPointer()) != 0;
22442 int utf8NameByteCount = Encoding.UTF8.GetByteCount(name);
22443 byte* utf8NameBytes;
22450 byte* stackPtr = stackalloc
byte[utf8NameByteCount + 1];
22451 utf8NameBytes = stackPtr;
22454 Util.
GetUtf8(name, utf8NameBytes, utf8NameByteCount);
22456 byte* pOpen =
null;
22473 public static bool MenuItem(
string label,
bool enabled) =>
MenuItem(label,
string.Empty,
false, enabled);